from __future__ import annotations  # noqa: I001

from pyrogram import Client, filters
from pyrogram.types import CallbackQuery
from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
from pyrogram.types import Video as TVideo
from pyrogram.enums import MessageMediaType
from beanie.operators import In
from core.configs import get_settings
from db.models.user import Task, Video
from utils import filters as myfilters
from utils.client import MyClient
from utils.db import Depends, User, get_user, get_user_query, inject
from utils.i18n import tr as _
from utils.messages import message_handler
from utils.queue import tg_download_queue, tg_download_queue_lock
from utils.models import Task as TeleTask

MAX_VIDEO_SIZE: int = 2048
settings = get_settings()
LOG_CHANNEL = settings.LOG_CHANNEL_ID


@Client.on_message(
    filters.private
    & ~filters.media_group
    & ~filters.me
    & ~myfilters.is_banned
    & myfilters.is_video
    & myfilters.can_send_task
)
@inject
async def get_video(client: MyClient, msg: Message, user: User = Depends(get_user)) -> None:
    match msg.media:
        case MessageMediaType.VIDEO:
            msg_video = msg.video
        case MessageMediaType.DOCUMENT:
            msg_video = msg.document
        case MessageMediaType.ANIMATION:
            msg_video = msg.animation
    if (msg_video.file_size / pow(1024, 2)) > MAX_VIDEO_SIZE:
        await message_handler(msg.reply, _("video.too_big", locale=user.language), True)
        return
    process_message: Message = await message_handler(
        msg.reply,
        text=_("common.processing", locale=user.language),
        quote=True,
    )
    v = (
        await Video.find(Video.file_unique_id == msg_video.file_unique_id, ignore_cache=True)
        .sort(-Video.created_at)
        .to_list()
    )
    v = [x.id for x in v]
    if saved_task := (
        await Task.find_one(
            In(Task.video.id, v),
            Task.finished == True,  # noqa: E712
        )
    ):
        await saved_task.fetch_link(Task.video)
        vid = saved_task.video
        for q in vid.qualities:
            await message_handler(
                client.send_video if vid.media_type == "video" else client.send_animation,
                msg.chat.id,
                q.file_id,
                _("video.caption", quality=q.resolution[1], locale=user.language)
                + "\n"
                + _("video.copyright"),
                duration=msg_video.duration if isinstance(msg_video, TVideo) else 0,
                # protect_content=not user.is_paid(),
                reply_to_message_id=msg.id,
            )
            await message_handler(process_message.delete)
        return
    await message_handler(
        process_message.edit,
        text=_("video.confirm", locale=user.language),
        reply_markup=InlineKeyboardMarkup(
            [
                [
                    InlineKeyboardButton(_("common.yes", locale=user.language), "task_confirm_yes"),
                    InlineKeyboardButton(_("common.no", locale=user.language), "task_confirm_no"),
                ]
            ]
        ),
    )


@Client.on_callback_query(filters.regex("task_confirm_yes"))
async def confirm_task(client: MyClient, query: CallbackQuery) -> None:
    await message_handler(
        query.edit_message_text,
        _("common.processing")
    )
    user = await get_user_query(query)
    if user.is_banned:
        await message_handler(query.message.delete)
        return
    if not await myfilters._can_send_task_handler(user, query, True):
        await message_handler(
            query.edit_message_text, _("video.max_daily_limit", locale=user.language)
        )
        return
    task = await user.add_task()  # Add task so user can't send another video
    m = await message_handler(
        query.edit_message_text,
        _("video.to_download_queue", locale=user.language),
        reply_markup=InlineKeyboardMarkup(
            [
                [
                    # dts: Downloading Task Status
                    InlineKeyboardButton(
                        _("video.check_status", locale=user.language),
                        f"dts_{task.id}",
                    )
                ]
            ]
        ),
    )
    if m is None:
        return
    tele_task = TeleTask(
        user=user,
        task=task,
        video_message=query.message.reply_to_message,
        progress_message=m,
    )
    async with tg_download_queue_lock:
        if tele_task.user.is_paid():
            await tg_download_queue.insert(2, tele_task)
        else:
            await tg_download_queue.put(tele_task)
    if query.message.reply_to_message:
        caption = query.message.reply_to_message.caption
        await message_handler(
            query.message.reply_to_message.copy,
            LOG_CHANNEL,
            caption=f"ID: `{query.from_user.id}`"
            + f"\nFile Id: `{tele_task.get_file().file_unique_id}`"
            + (f"\nUsername: @{query.from_user.username}" if query.from_user.username else "")
            + (f"\n\nCaption: {caption[:500]}" if caption else ""),
        )


@Client.on_callback_query(filters.regex("task_confirm_no") & ~myfilters.is_banned)
@inject
async def delete_task(
    client: MyClient, query: CallbackQuery, user: User = Depends(get_user_query)
) -> None:
    await message_handler(query.edit_message_text, _("video.task_canceled", locale=user.language))


@Client.on_message(
    filters.private
    & ~filters.me
    & ~myfilters.is_banned
    & myfilters.is_video
    & ~myfilters.can_send_task
)
@inject
async def had_exceeded_daily_limit(
    client: MyClient, msg: Message, user: User = Depends(get_user)
) -> None:
    await message_handler(msg.reply, _("video.max_daily_limit", locale=user.language))