from __future__ import annotations

import re

from pyrogram import Client, filters
from pyrogram.types import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, Message
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 i18n, tr as _
from utils.messages import message_handler

CHANGE_LANGUAGE_PATTERN = re.compile(r"^set_language_(?P<code_name>[a-z]{2,3})$")


async def send_main_menu(client: MyClient, update: Message | CallbackQuery, user: User) -> None:
    func = update.edit_message_text if isinstance(update, CallbackQuery) else update.reply_text

    await message_handler(
        func,
        _(
            "settings.main",
            user_id=update.from_user.id,
            first_name=update.from_user.first_name,
            points=user.points,
            subscription=_(f"settings.{user.subscription}", locale=user.language),
            remaining_tasks=await user.remaining_tasks(),
            locale=user.language,
        ),
        reply_markup=InlineKeyboardMarkup(
            [
                [
                    InlineKeyboardButton(
                        _("settings.change_language", locale=user.language),
                        "settings_change-language",
                    )
                ]
            ]
        ),
    )


@Client.on_message(filters.private & filters.command(["settings"]) & ~myfilters.is_banned)
@inject
async def main_menu(client: MyClient, msg: Message, user: User = Depends(get_user)) -> None:
    await send_main_menu(client, msg, user)


@Client.on_callback_query(filters.regex("settings_main-menu") & ~myfilters.is_banned)
@inject
async def main_menu_query(
    client: MyClient, query: CallbackQuery, user: User = Depends(get_user_query)
) -> None:
    await send_main_menu(client, query, user)


@Client.on_callback_query(filters.regex("settings_change-language") & ~myfilters.is_banned)
@inject
async def change_language(
    client: MyClient, query: CallbackQuery, user: User = Depends(get_user_query)
) -> None:
    languages = list(
        map(lambda lang: (lang.config.name, lang.config.code_name), i18n._locales.values())
    )
    keyboard = list(
        map(
            lambda lang: InlineKeyboardButton(
                f"{lang[0]}✅" if lang[1] == user.language else lang[0],
                f"set_language_{lang[1]}",
            ),
            languages,
        ),
    )
    keyboard = [keyboard[i : i + 2] for i in range(0, len(keyboard), 2)]
    keyboard.append(
        [InlineKeyboardButton(_("common.back", locale=user.language), "settings_main-menu")]
    )
    await message_handler(
        query.edit_message_text,
        _("settings.choose_language", locale=user.language),
        reply_markup=InlineKeyboardMarkup(keyboard),
    )


@Client.on_callback_query(filters.regex(CHANGE_LANGUAGE_PATTERN) & ~myfilters.is_banned)
@inject
async def set_language(
    client: MyClient, query: CallbackQuery, user: User = Depends(get_user_query)
) -> None:
    language_code: str = query.matches[0].group("code_name")
    if language_code == user.language:
        await message_handler(
            query.answer,
            _("settings.language_changed", locale=user.language),
            show_alert=True,
            cache_time=20,
        )
        return
    user.settings.language = language_code
    await user.save()
    await message_handler(
        query.answer, _("settings.language_changed", locale=user.language), show_alert=True
    )
    languages = list(
        map(lambda lang: (lang.config.name, lang.config.code_name), i18n._locales.values())
    )
    keyboard = list(
        map(
            lambda lang: [
                InlineKeyboardButton(
                    f"{lang[0]}✅" if lang[1] == user.language else lang[0],
                    f"set_language_{lang[1]}",
                )
            ],
            languages,
        ),
    )
    keyboard.append(
        [InlineKeyboardButton(_("common.back", locale=user.language), "settings_main-menu")]
    )
    await message_handler(
        query.edit_message_text,
        _("settings.choose_language", locale=user.language),
        reply_markup=InlineKeyboardMarkup(keyboard),
    )


@Client.on_message(filters.command(["referral"]) & ~myfilters.is_banned)
@inject
async def send_referral(client: MyClient, msg: Message, user: User = Depends(get_user)) -> None:
    await message_handler(
        msg.reply,
        _(
            "settings.referral_message",
            referral_link=f"https://t.me/ResizeVideoBot?start=referral_{msg.from_user.id}",
            users_joined=await user.users_joined_by(),
            locale=user.language,
        ),
    )