import json
from pathlib import Path
from typing import Any, Optional
from uuid import UUID
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from core.logging import get_logger
from modules.i18n.models import Translation, TenantLocale

logger = get_logger(__name__)
LOCALES_DIR = Path(__file__).resolve().parent / "locales"


class TranslationRepository:
    """Manages translation retrieval from filesystem and database overrides."""
    _file_cache: dict[str, dict[str, str]] = {}

    @classmethod
    def _get_file_key(cls, locale: str, namespace: str) -> str:
        return f"{locale}:{namespace}"

    @classmethod
    def load_file_translations(cls, locale: str, namespace: str) -> dict[str, str]:
        cache_key = cls._get_file_key(locale, namespace)
        if cache_key in cls._file_cache:
            return cls._file_cache[cache_key]

        file_path = LOCALES_DIR / locale / f"{namespace}.json"
        if not file_path.exists():
            return {}

        try:
            with open(file_path, "r", encoding="utf-8") as f:
                data = json.load(f)
                cls._file_cache[cache_key] = data
                return data
        except Exception as exc:
            logger.error("failed_loading_locale_file", file=str(file_path), error=str(exc))
            return {}

    @classmethod
    def get_static_translation(cls, locale: str, namespace: str, key: str) -> Optional[str]:
        translations = cls.load_file_translations(locale, namespace)
        return translations.get(key)

    @classmethod
    async def get_db_translation(
        cls,
        db: AsyncSession,
        locale: str,
        namespace: str,
        key: str,
        tenant_id: Optional[UUID] = None,
    ) -> Optional[str]:
        stmt = (
            select(Translation.value)
            .where(
                Translation.locale == locale,
                Translation.namespace == namespace,
                Translation.key == key,
                Translation.is_approved == True,
            )
        )
        if tenant_id:
            stmt = stmt.where(Translation.tenant_id == tenant_id)
        else:
            stmt = stmt.where(Translation.tenant_id.is_(None))

        res = await db.execute(stmt)
        return res.scalar_one_or_none()

    @classmethod
    async def save_db_translation(
        cls,
        db: AsyncSession,
        locale: str,
        namespace: str,
        key: str,
        value: str,
        tenant_id: Optional[UUID] = None,
        is_approved: bool = True,
    ) -> Translation:
        stmt = select(Translation).where(
            Translation.locale == locale,
            Translation.namespace == namespace,
            Translation.key == key,
        )
        if tenant_id:
            stmt = stmt.where(Translation.tenant_id == tenant_id)
        else:
            stmt = stmt.where(Translation.tenant_id.is_(None))

        res = await db.execute(stmt)
        record = res.scalar_one_or_none()
        if record:
            record.value = value
            record.is_approved = is_approved
        else:
            record = Translation(
                tenant_id=tenant_id,
                locale=locale,
                namespace=namespace,
                key=key,
                value=value,
                is_approved=is_approved,
            )
            db.add(record)
        await db.flush()
        return record

    @classmethod
    async def list_pending_translations(
        cls,
        db: AsyncSession,
        tenant_id: Optional[UUID] = None,
    ) -> list[Translation]:
        stmt = select(Translation).where(Translation.is_approved == False)
        if tenant_id:
            stmt = stmt.where((Translation.tenant_id == tenant_id) | (Translation.tenant_id.is_(None)))
        stmt = stmt.order_by(Translation.created_at.desc())
        res = await db.execute(stmt)
        return list(res.scalars().all())

    @classmethod
    async def get_translation_by_id(
        cls,
        db: AsyncSession,
        translation_id: UUID,
    ) -> Optional[Translation]:
        stmt = select(Translation).where(Translation.id == translation_id)
        res = await db.execute(stmt)
        return res.scalar_one_or_none()

    @classmethod
    async def approve_translation(
        cls,
        db: AsyncSession,
        translation_id: UUID,
    ) -> Optional[Translation]:
        record = await cls.get_translation_by_id(db, translation_id)
        if record:
            record.is_approved = True
            await db.flush()
        return record

    @classmethod
    async def delete_translation(
        cls,
        db: AsyncSession,
        translation_id: UUID,
    ) -> bool:
        record = await cls.get_translation_by_id(db, translation_id)
        if record:
            await db.delete(record)
            await db.flush()
            return True
        return False

    @classmethod
    async def list_tenant_locales(
        cls,
        db: AsyncSession,
        tenant_id: UUID,
    ) -> list[TenantLocale]:
        stmt = select(TenantLocale).where(TenantLocale.tenant_id == tenant_id, TenantLocale.is_enabled == True)
        res = await db.execute(stmt)
        return list(res.scalars().all())

    @classmethod
    async def set_tenant_locales(
        cls,
        db: AsyncSession,
        tenant_id: UUID,
        locales: list[str],
    ) -> list[TenantLocale]:
        # Delete old
        existing = await db.execute(select(TenantLocale).where(TenantLocale.tenant_id == tenant_id))
        for r in existing.scalars().all():
            await db.delete(r)
        await db.flush()

        results = []
        for loc in locales:
            tl = TenantLocale(tenant_id=tenant_id, locale=loc, is_enabled=True)
            db.add(tl)
            results.append(tl)
        await db.flush()
        return results

    @classmethod
    def clear_cache(cls) -> None:
        cls._file_cache.clear()
