from typing import Any, Awaitable, Callable, Dict
from aiogram import BaseMiddleware
from aiogram.types import TelegramObject, User as TgUser, InlineKeyboardMarkup, InlineKeyboardButton
from modules.i18n.locale_manager import LocaleManager, SUPPORTED_LOCALES
from modules.i18n.fallback import FallbackResolver
from modules.i18n.translator import t as translate_fast


def build_language_keyboard(prefix: str = "set_lang:") -> InlineKeyboardMarkup:
    """Builds inline keyboard for Telegram language selection menu."""
    buttons: list[list[InlineKeyboardButton]] = []
    row: list[InlineKeyboardButton] = []

    for code, meta in SUPPORTED_LOCALES.items():
        text = f"{meta.flag} {meta.native_name}"
        button = InlineKeyboardButton(text=text, callback_data=f"{prefix}{code}")
        row.append(button)
        if len(row) == 2:
            buttons.append(row)
            row = []

    if row:
        buttons.append(row)

    return InlineKeyboardMarkup(inline_keyboard=buttons)


class TelegramLocalizationMiddleware(BaseMiddleware):
    """Aiogram 3 Localization Middleware."""

    async def __call__(
        self,
        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
        event: TelegramObject,
        data: Dict[str, Any],
    ) -> Any:
        # Extract telegram user
        user: TgUser | None = getattr(event, "from_user", None)

        bot_locale = data.get("bot_default_locale", "en")
        tenant_locale = data.get("tenant_default_locale", "en")
        stored_user_locale = data.get("user_locale")

        # Telegram client language fallback if not explicitly stored
        telegram_client_lang = user.language_code if user else None

        candidates = FallbackResolver.get_candidate_locales(
            user_locale=stored_user_locale or telegram_client_lang,
            bot_locale=bot_locale,
            tenant_locale=tenant_locale,
        )
        resolved_locale = candidates[0] if candidates else "en"

        # Inject into handler data
        data["locale"] = resolved_locale
        data["is_rtl"] = LocaleManager.is_rtl(resolved_locale)
        data["t"] = lambda key, **kwargs: translate_fast(key, locale=resolved_locale, **kwargs)

        return await handler(event, data)
