from celery import chain
from base import SPANNER_TELEGRAM_API, TELEGRAM_API
from base.utils import RedisDatabase
from base.utils.funcs import *

def isolate_softsub_workflow(admin_user_id: int, username: str, file_name: str, file_id: str, subtitle: str):
    from celery_tasks.tasks.softsub_handler import convert_to_softsub
    from celery_tasks.tasks.uploader import upload_video_and_submit_request

    request_id = int()
    request_type_str = 'SoftSub'
    title_id = int()
    title_name = str()
    title_type = int()

    server_file_name, file_format = download_video(SPANNER_TELEGRAM_API,file_id,file_name)
    if file_format != '.mkv': server_file_name = convert_to_mkv(server_file_name, file_format)
    sec = get_video_duration_seconds(f'{DOWNLOAD_DIR}{server_file_name}')

    fake_result = {
        'status': True,
        'api_url': SPANNER_TELEGRAM_API,
        'user_id': admin_user_id,
        'username': username,
        'admin_review': None,
        'server_file_name': server_file_name,
        'subtitle': subtitle,
        'sync_score': 'N/A',
        'duration': sec
    }

    workflow = chain(
        convert_to_softsub.s(fake_result,file_name),
        upload_video_and_submit_request.s(request_id, request_type_str, title_id, title_type, title_name, file_name, file_id),
    )
    workflow.apply_async()

def isolate_hardsub_workflow(admin_user_id: int, username: str, file_name: str, file_id: str, subtitle: str):
    from celery_tasks.tasks.hardsub_handler import convert_to_hardsub
    from celery_tasks.tasks.uploader import upload_video_and_submit_request

    request_id = int()
    request_type_str = 'HardSub'
    title_id = int()
    title_name = str()
    title_type = int()

    server_file_name, file_format = download_video(SPANNER_TELEGRAM_API,file_id,file_name)
    if file_format != '.mkv': server_file_name = convert_to_mkv(server_file_name, file_format)
    sec = get_video_duration_seconds(f'{DOWNLOAD_DIR}{server_file_name}')
    random_sec = get_random_second(sec)

    fake_result = {
        'status': True,
        'api_url': SPANNER_TELEGRAM_API,
        'user_id': admin_user_id,
        'username': username,
        'admin_review': None,
        'server_file_name': server_file_name,
        'subtitle': subtitle,
        'sync_score': 'N/A',
        'duration': sec,
        'random_sec': random_sec
    }

    workflow = chain(
        convert_to_hardsub.s(fake_result,file_name),
        upload_video_and_submit_request.s(request_id, request_type_str, title_id, title_type, title_name, file_name, file_id),
    )
    workflow.apply_async()

def isolate_dubbed_workflow(admin_user_id: int, username: str, file_name: str, file_id: str, audio_url: str):
    from celery_tasks.tasks.dubbed_handler import convert_to_dubbed
    from celery_tasks.tasks.uploader import upload_video_and_submit_request

    request_id = int()
    request_type_str = 'Dubbed'
    title_id = int()
    title_name = str()
    title_type = int()

    server_file_name, file_format = download_video(SPANNER_TELEGRAM_API,file_id,file_name)
    if file_format != '.mkv': server_file_name = convert_to_mkv(server_file_name, file_format)
    sec = get_video_duration_seconds(f'{DOWNLOAD_DIR}{server_file_name}')

    fake_result = {
        'status': True,
        'api_url': SPANNER_TELEGRAM_API,
        'user_id': admin_user_id,
        'username': username,
        'admin_review': None,
        'server_file_name': server_file_name,
        'audio_url': audio_url,
        'sync_score': 'N/A',
        'duration': sec
    }

    workflow = chain(
        convert_to_dubbed.s(fake_result,file_name),
        upload_video_and_submit_request.s(request_id, request_type_str, title_id, title_type, title_name, file_name, file_id),
    )
    workflow.apply_async()

def isolate_quality_workflow(admin_user_id: int, username: str, file_name: str, file_id: str, requested_quality: str):
    from celery_tasks.tasks.quality_handler import preparing_file_and_convert_quality
    from celery_tasks.tasks.uploader import upload_document

    sending_details = {
        'api_url': SPANNER_TELEGRAM_API,
        'user_id': admin_user_id,
        'username': username
    }

    workflow = chain(
        preparing_file_and_convert_quality.s(sending_details, requested_quality, int(), file_name, file_id, int(), int()),
        upload_document.s(),
    )
    workflow.apply_async()

def softsub_workflow(request_id: int, file_name: str, file_id: str):
    from celery_tasks.tasks.subtitle_sync_engine import find_and_synchronize_subtitle
    from celery_tasks.tasks.softsub_handler import convert_to_softsub
    from celery_tasks.tasks.uploader import upload_video_and_submit_request

    with RedisDatabase() as r: r.incr(f"request:active:{request_id}")

    admin_user_id, request_type_str, _, title_id, imdb_id, title_name, title_type = get_all_request_info(request_id)

    workflow = chain(
        find_and_synchronize_subtitle.s(admin_user_id, request_id, request_type_str, imdb_id, title_type, file_name, file_id),
        convert_to_softsub.s(file_name),
        upload_video_and_submit_request.s(request_id, request_type_str, title_id, title_type, title_name, file_name, file_id),
    )
    workflow.apply_async()

def hardsub_workflow(request_id: int, file_name: str, file_id: str):
    from celery_tasks.tasks.subtitle_sync_engine import find_and_synchronize_subtitle
    from celery_tasks.tasks.hardsub_handler import convert_to_hardsub
    from celery_tasks.tasks.uploader import upload_video_and_submit_request

    with RedisDatabase() as r: r.incr(f"request:active:{request_id}")

    admin_user_id, request_type_str, _, title_id, imdb_id, title_name, title_type = get_all_request_info(request_id)

    workflow = chain(
        find_and_synchronize_subtitle.s(admin_user_id, request_id, request_type_str, imdb_id, title_type, file_name, file_id),
        convert_to_hardsub.s(file_name),
        upload_video_and_submit_request.s(request_id, request_type_str, title_id, title_type, title_name, file_name, file_id),
    )
    workflow.apply_async()

def softsub_to_hardsub_workflow(request_id: int, file_name: str, file_id: str):
    from celery_tasks.tasks.hardsub_handler import convert_softsub_to_hardsub
    from celery_tasks.tasks.uploader import upload_video_and_submit_request

    with RedisDatabase() as r: r.incr(f"request:active:{request_id}")

    admin_user_id, request_type_str, _, title_id, imdb_id, title_name, title_type = get_all_request_info(request_id)

    workflow = chain(
        convert_softsub_to_hardsub.s(admin_user_id, request_id, request_type_str, file_id, file_name),
        upload_video_and_submit_request.s(request_id, request_type_str, title_id, title_type, title_name, file_name, file_id),
    )
    workflow.apply_async()

def quality_workflow(request_id: int, movieo_file_id: int, file_name: str, file_id: str):
    from celery_tasks.tasks.quality_handler import preparing_file_and_convert_quality
    from celery_tasks.tasks.uploader import upload_document
    from celery_tasks.tasks.quality_handler import decrement_counter_and_submit_request

    with RedisDatabase() as r: r.incr(f"request:active:{request_id}")

    admin_user_id, request_type_str, requested_season, title_id, imdb_id, title_name, title_type = get_all_request_info(request_id)

    if len(request_type_str.split('+')) == 2:
        requested_quality = request_type_str.split('+')[0]
    else:
        requested_quality = request_type_str.split(' ')[0]

    sending_details = {
        'api_url': TELEGRAM_API,
        'user_id': -1003065180861
    }

    workflow = chain(
        preparing_file_and_convert_quality.s(sending_details, requested_quality.strip(), movieo_file_id, file_name, file_id, title_id, title_type),
        upload_document.s(),
        decrement_counter_and_submit_request.s(admin_user_id, request_id, request_type_str, requested_season, requested_quality, title_type, title_name)
    )
    workflow.apply_async()

def get_quality_from_sources_workflow(request_id: int):
    from celery_tasks.tasks.find_title_from_sources import find_title
    from celery_tasks.tasks.quality_handler import route_quality_conversion_request
    from celery_tasks.tasks.url_downloader import download_from_url
    from celery_tasks.tasks.uploader import upload_document
    from celery_tasks.tasks.quality_handler import resolve_quality_conversion_request

    admin_user_id, request_type_str, requested_season, title_id, imdb_id, title_name, title_type = get_all_request_info(request_id)

    if title_type == 1:
        requested_season = 100

    if len(request_type_str.split('+')) == 2:
        requested_quality = request_type_str.split('+')[0]
    else:
        requested_quality = request_type_str.split(' ')[0]

    workflow = chain(
        find_title.s(imdb_id, title_name, requested_season, requested_quality.strip()),
        route_quality_conversion_request.s(title_id, title_type, title_name, request_id, requested_season, requested_quality.strip()),
        download_from_url.s(),
        upload_document.s(),
        resolve_quality_conversion_request.s(admin_user_id, request_id, request_type_str, requested_season, requested_quality.strip(), title_type, title_name).set(countdown=5)
    )
    workflow.apply_async()


def get_title_from_sources_workflow(request_id: int, title_name: str):
    from celery_tasks.tasks.find_title_from_sources import find_title
    from celery_tasks.tasks.title_request_handler import add_title_to_database
    from celery_tasks.tasks.url_downloader import download_from_url
    from celery_tasks.tasks.uploader import upload_document
    from celery_tasks.tasks.title_request_handler import submit_title_request

    admin_user_id, request_type_str, _, _, imdb_id, _, _ = get_all_request_info(request_id)

    workflow = chain(
        find_title.s(imdb_id, title_name, 100, 'all'),
        add_title_to_database.s(imdb_id),
        download_from_url.s(),
        upload_document.s(),
        submit_title_request.s(admin_user_id, request_id, imdb_id, title_name)
    )
    workflow.apply_async()

def title_updater_workflow(update_info):
    from celery_tasks.tasks.url_downloader import download_from_url
    from celery_tasks.tasks.uploader import upload_document

    workflow = chain(
        download_from_url.s(update_info),
        upload_document.s(),
    )
    workflow.apply_async()