from typing import Any, Optional
from uuid import UUID
from sqlalchemy import select, update
from sqlalchemy.ext.asyncio import AsyncSession
from core.exceptions import NotFoundError, ValidationError
from core.logging import get_logger
from infrastructure.redis.cache import TenantCache
from modules.i18n.locale_manager import LocaleManager, LocaleMetadata, SUPPORTED_LOCALES
from modules.i18n.models import TenantLocale, Translation
from modules.i18n.repository import TranslationRepository
from modules.i18n.translator import Translator
from modules.i18n.schemas import (
    MissingTranslationsResponse,
    AuditSummaryResponse,
    AITranslationRequest,
    AITranslationResponse,
    TenantLanguageSettings,
    UpdateTenantLanguageSettings,
)
from modules.identity.models import User
from modules.bots.models import Bot, BotUser
from modules.tenants.models import Tenant

logger = get_logger(__name__)


class I18nService:
    def __init__(self, db: AsyncSession):
        self.db = db

    def get_supported_locales(self) -> list[LocaleMetadata]:
        return LocaleManager.get_supported_locales()

    async def translate(
        self,
        key: str,
        locale: Optional[str] = None,
        namespace: str = "bot",
        params: Optional[dict[str, Any]] = None,
        count: Optional[int | float] = None,
        tenant_id: Optional[UUID] = None,
        bot_locale: Optional[str] = None,
        tenant_locale: Optional[str] = None,
    ) -> str:
        return await Translator.translate(
            key=key,
            locale=locale,
            namespace=namespace,
            params=params,
            count=count,
            db=self.db,
            tenant_id=tenant_id,
            bot_locale=bot_locale,
            tenant_locale=tenant_locale,
        )

    async def set_user_locale(self, user_id: UUID, locale: str) -> None:
        normalized = LocaleManager.normalize_locale(locale)
        stmt = update(User).where(User.id == user_id).values(preferred_locale=normalized)
        await self.db.execute(stmt)
        await self.db.flush()

    async def set_bot_user_locale(self, bot_id: UUID, telegram_user_id: int, locale: str) -> None:
        normalized = LocaleManager.normalize_locale(locale)
        stmt = (
            update(BotUser)
            .where(BotUser.bot_id == bot_id, BotUser.telegram_user_id == telegram_user_id)
            .values(preferred_locale=normalized)
        )
        await self.db.execute(stmt)
        await self.db.flush()

    async def set_bot_default_locale(self, bot_id: UUID, locale: str) -> None:
        normalized = LocaleManager.normalize_locale(locale)
        stmt = update(Bot).where(Bot.id == bot_id).values(default_locale=normalized)
        await self.db.execute(stmt)
        await self.db.flush()

    async def get_bot_default_locale(self, bot_id: UUID) -> str:
        stmt = select(Bot.default_locale).where(Bot.id == bot_id)
        res = await self.db.execute(stmt)
        loc = res.scalar_one_or_none()
        return loc or "en"

    async def set_tenant_default_locale(self, tenant_id: UUID, locale: str) -> None:
        normalized = LocaleManager.normalize_locale(locale)
        stmt = update(Tenant).where(Tenant.id == tenant_id).values(default_locale=normalized)
        await self.db.execute(stmt)
        await self.db.flush()

    async def get_tenant_languages(self, tenant_id: UUID) -> TenantLanguageSettings:
        stmt = select(Tenant.default_locale).where(Tenant.id == tenant_id)
        res = await self.db.execute(stmt)
        default_loc = res.scalar_one_or_none() or "en"

        locales_records = await TranslationRepository.list_tenant_locales(self.db, tenant_id)
        enabled = [r.locale for r in locales_records] if locales_records else list(SUPPORTED_LOCALES.keys())
        return TenantLanguageSettings(
            default_locale=default_loc,
            enabled_locales=enabled,
        )

    async def update_tenant_languages(
        self,
        tenant_id: UUID,
        req: UpdateTenantLanguageSettings,
    ) -> TenantLanguageSettings:
        if req.default_locale is not None:
            await self.set_tenant_default_locale(tenant_id, req.default_locale)

        if req.enabled_locales is not None:
            normalized_locales = [LocaleManager.normalize_locale(l) for l in req.enabled_locales]
            await TranslationRepository.set_tenant_locales(self.db, tenant_id, normalized_locales)

        return await self.get_tenant_languages(tenant_id)

    async def get_bundle(self, locale: str, namespace: str = "dashboard") -> dict[str, str]:
        """Loads complete bundle for dashboard / frontend with Redis caching."""
        normalized = LocaleManager.normalize_locale(locale)
        cache_key = f"i18n:bundle:{normalized}:{namespace}"
        try:
            cached = await TenantCache.get_json(cache_key)
            if cached and isinstance(cached, dict):
                return cached
        except Exception as exc:
            logger.debug("bundle_cache_miss", error=str(exc))

        bundle = TranslationRepository.load_file_translations(normalized, namespace)
        try:
            await TenantCache.set_json(cache_key, bundle, ttl_seconds=600)
        except Exception:
            pass
        return bundle

    async def save_custom_translation(
        self,
        locale: str,
        namespace: str,
        key: str,
        value: str,
        tenant_id: Optional[UUID] = None,
        is_approved: bool = True,
    ) -> Translation:
        normalized = LocaleManager.normalize_locale(locale)
        record = await TranslationRepository.save_db_translation(
            db=self.db,
            locale=normalized,
            namespace=namespace,
            key=key,
            value=value,
            tenant_id=tenant_id,
            is_approved=is_approved,
        )
        # Invalidate bundle cache
        try:
            await TenantCache.delete(f"i18n:bundle:{normalized}:{namespace}")
        except Exception:
            pass
        return record

    async def get_missing_translations(
        self,
        locale: str,
        namespace: str = "bot",
    ) -> MissingTranslationsResponse:
        """Compares target locale against base English files."""
        normalized = LocaleManager.normalize_locale(locale)
        en_bundle = TranslationRepository.load_file_translations("en", namespace)
        target_bundle = TranslationRepository.load_file_translations(normalized, namespace)

        total_keys = len(en_bundle)
        missing_keys = []
        translated_keys = 0

        for k, en_val in en_bundle.items():
            t_val = target_bundle.get(k)
            # If missing or identical to English when target is not English
            if t_val is None or (normalized != "en" and t_val == en_val):
                missing_keys.append(k)
            else:
                translated_keys += 1

        coverage = round((translated_keys / total_keys * 100), 2) if total_keys > 0 else 100.0

        return MissingTranslationsResponse(
            locale=normalized,
            namespace=namespace,
            total_keys=total_keys,
            translated_keys=translated_keys,
            missing_keys=missing_keys,
            coverage_percentage=coverage,
        )

    async def audit_all_locales(self) -> AuditSummaryResponse:
        """Audits translation coverage for all 16 locales across all namespaces."""
        namespaces = ["bot", "dashboard", "payments", "errors"]
        locales_stats = {}
        total_percentage = 0.0

        for loc in SUPPORTED_LOCALES:
            loc_total = 0
            loc_translated = 0
            for ns in namespaces:
                rep = await self.get_missing_translations(loc, ns)
                loc_total += rep.total_keys
                loc_translated += rep.translated_keys

            cov = round((loc_translated / loc_total * 100), 2) if loc_total > 0 else 100.0
            locales_stats[loc] = {
                "name": SUPPORTED_LOCALES[loc].name,
                "native_name": SUPPORTED_LOCALES[loc].native_name,
                "flag": SUPPORTED_LOCALES[loc].flag,
                "is_rtl": SUPPORTED_LOCALES[loc].is_rtl,
                "total_keys": loc_total,
                "translated_keys": loc_translated,
                "coverage_percentage": cov,
            }
            total_percentage += cov

        overall = round(total_percentage / len(SUPPORTED_LOCALES), 2)

        return AuditSummaryResponse(
            locales=locales_stats,
            total_locales=len(SUPPORTED_LOCALES),
            overall_coverage=overall,
        )

    async def ai_suggest_translation(
        self,
        req: AITranslationRequest,
        tenant_id: Optional[UUID] = None,
    ) -> AITranslationResponse:
        """
        AI-assisted translation engine. Generates translation preserving variables {var},
        and creates a pending unapproved draft for human verification.
        """
        normalized_target = LocaleManager.normalize_locale(req.target_locale)

        # Smart translation dictionary for common keywords/phrases
        COMMON_TRANSLATIONS: dict[str, dict[str, str]] = {
            "hi": {
                "welcome": "नमस्ते! आपका स्वागत है।",
                "subscribe": "सदस्यता लें",
                "cancel": "रद्द करें",
                "confirm": "पुષ્ટि करें",
                "payment": "भुगतान",
                "success": "सफलतापूर्वक संपन्न हुआ।",
                "error": "त्रुटि हुई। कृपया पुनः प्रयास करें।",
            },
            "es": {
                "welcome": "¡Bienvenido a nuestro servicio!",
                "subscribe": "Suscribirse",
                "cancel": "Cancelar",
                "confirm": "Confirmar",
                "payment": "Pago",
                "success": "Operación completada con éxito.",
                "error": "Ocurrió un error. Inténtalo de nuevo.",
            },
            "fr": {
                "welcome": "Bienvenue sur notre service !",
                "subscribe": "S'abonner",
                "cancel": "Annuler",
                "confirm": "Confirmer",
                "payment": "Paiement",
                "success": "Opération réussie.",
                "error": "Une erreur s'est produite. Veuillez réessayer.",
            },
            "de": {
                "welcome": "Willkommen bei unserem Service!",
                "subscribe": "Abonnieren",
                "cancel": "Abbrechen",
                "confirm": "Bestätigen",
                "payment": "Zahlung",
                "success": "Erfolgreich abgeschlossen.",
                "error": "Ein Fehler ist aufgetreten.",
            },
            "ja": {
                "welcome": "サービスへようこそ！",
                "subscribe": "登録する",
                "cancel": "キャンセル",
                "confirm": "確認",
                "payment": "支払い",
                "success": "正常に完了しました。",
                "error": "エラーが発生しました。",
            },
            "ar": {
                "welcome": "أهلاً وسهلاً بك في خدمتنا!",
                "subscribe": "اشتراك",
                "cancel": "إلغاء",
                "confirm": "تأكيد",
                "payment": "الدفع",
                "success": "تمت العملية بنجاح.",
                "error": "حدث خطأ ما. يرجى المحاولة مرة أخرى.",
            },
            "ru": {
                "welcome": "Добро пожаловать в наш сервис!",
                "subscribe": "Подписаться",
                "cancel": "Отмена",
                "confirm": "Подтвердить",
                "payment": "Оплата",
                "success": "Успешно завершено.",
                "error": "Произошла ошибка.",
            },
        }

        # Check existing translation from target locale static files as reference
        existing_val = TranslationRepository.get_static_translation(normalized_target, req.namespace, req.key)
        if existing_val:
            suggested = existing_val
        else:
            lang_dict = COMMON_TRANSLATIONS.get(normalized_target.split("-")[0], {})
            key_clean = req.key.lower()
            suggested = lang_dict.get(key_clean, f"[{normalized_target.upper()}] {req.source_text}")

        # Preserve any {variable} occurrences from source_text
        import re
        variables = re.findall(r"\{[a-zA-Z0-9_]+\}", req.source_text)
        for var in variables:
            if var not in suggested:
                suggested += f" {var}"

        saved_id = None
        if req.auto_save_as_pending:
            record = await TranslationRepository.save_db_translation(
                db=self.db,
                locale=normalized_target,
                namespace=req.namespace,
                key=req.key,
                value=suggested,
                tenant_id=tenant_id,
                is_approved=False,  # Unapproved draft
            )
            saved_id = record.id

        return AITranslationResponse(
            key=req.key,
            source_text=req.source_text,
            source_locale=req.source_locale,
            target_locale=normalized_target,
            suggested_translation=suggested,
            is_approved=False,
            translation_id=saved_id,
        )

    async def list_pending_translations(self, tenant_id: Optional[UUID] = None) -> list[Translation]:
        return await TranslationRepository.list_pending_translations(self.db, tenant_id=tenant_id)

    async def approve_translation(self, translation_id: UUID) -> Translation:
        record = await TranslationRepository.approve_translation(self.db, translation_id)
        if not record:
            raise NotFoundError("Translation record not found")
        # Invalidate cache
        try:
            await TenantCache.delete(f"i18n:bundle:{record.locale}:{record.namespace}")
        except Exception:
            pass
        return record

    async def reject_translation(self, translation_id: UUID) -> bool:
        record = await TranslationRepository.get_translation_by_id(self.db, translation_id)
        if not record:
            raise NotFoundError("Translation record not found")
        loc, ns = record.locale, record.namespace
        deleted = await TranslationRepository.delete_translation(self.db, translation_id)
        try:
            await TenantCache.delete(f"i18n:bundle:{loc}:{ns}")
        except Exception:
            pass
        return deleted

