import re
from typing import Any, Optional
from uuid import UUID
from sqlalchemy.ext.asyncio import AsyncSession
from core.logging import get_logger
from modules.i18n.fallback import FallbackResolver
from modules.i18n.locale_manager import DEFAULT_LOCALE
from modules.i18n.pluralization import PluralRules
from modules.i18n.repository import TranslationRepository
from modules.i18n.resolver import get_current_locale

logger = get_logger(__name__)


class Translator:
    """Core translation engine with interpolation, pluralization, and fallbacks."""

    @classmethod
    def interpolate(cls, template: str, params: Optional[dict[str, Any]] = None) -> str:
        if not params:
            return template

        def replacer(match):
            param_key = match.group(1)
            return str(params.get(param_key, match.group(0)))

        return re.sub(r"\{(\w+)\}", replacer, template)

    @classmethod
    async def get_raw_text(
        cls,
        key: str,
        locale: str,
        namespace: str = "bot",
        db: Optional[AsyncSession] = None,
        tenant_id: Optional[UUID] = None,
    ) -> Optional[str]:
        # 1. Check DB tenant override
        if db:
            db_val = await TranslationRepository.get_db_translation(db, locale, namespace, key, tenant_id)
            if db_val is not None:
                return db_val

        # 2. Check Static Files
        file_val = TranslationRepository.get_static_translation(locale, namespace, key)
        if file_val is not None:
            return file_val

        return None

    @classmethod
    async def translate(
        cls,
        key: str,
        locale: Optional[str] = None,
        namespace: str = "bot",
        params: Optional[dict[str, Any]] = None,
        count: Optional[int | float] = None,
        db: Optional[AsyncSession] = None,
        tenant_id: Optional[UUID] = None,
        bot_locale: Optional[str] = None,
        tenant_locale: Optional[str] = None,
    ) -> str:
        requested_locale = locale or get_current_locale()
        fallback_chain = FallbackResolver.get_candidate_locales(
            user_locale=requested_locale,
            bot_locale=bot_locale,
            tenant_locale=tenant_locale,
        )

        # Pluralization suffix key
        target_keys = [key]
        if count is not None:
            cat = PluralRules.get_category(requested_locale, count)
            target_keys = [f"{key}_{cat}", key]
            if params is None:
                params = {}
            params.setdefault("count", count)

        # Search candidates in fallback order
        for loc in fallback_chain:
            for t_key in target_keys:
                raw_text = await cls.get_raw_text(t_key, loc, namespace, db, tenant_id)
                if raw_text is not None:
                    return cls.interpolate(raw_text, params)

        logger.warning(
            "missing_translation",
            key=key,
            locale=requested_locale,
            namespace=namespace,
            fallback_chain=fallback_chain,
        )
        # Return fallback or readable key
        return cls.interpolate(key, params)


# Synchronous / Fast filesystem translation helper
def t(
    key: str,
    locale: Optional[str] = None,
    namespace: str = "bot",
    params: Optional[dict[str, Any]] = None,
    count: Optional[int | float] = None,
) -> str:
    loc = locale or get_current_locale()
    fallback_chain = FallbackResolver.get_candidate_locales(user_locale=loc)

    target_keys = [key]
    if count is not None:
        cat = PluralRules.get_category(loc, count)
        target_keys = [f"{key}_{cat}", key]
        if params is None:
            params = {}
        params.setdefault("count", count)

    for l in fallback_chain:
        for k in target_keys:
            raw = TranslationRepository.get_static_translation(l, namespace, k)
            if raw is not None:
                return Translator.interpolate(raw, params)

    return Translator.interpolate(key, params)
