"""Translation-internal language metadata."""

from __future__ import annotations

from functools import lru_cache
from typing import Dict, Mapping, Optional, Tuple

from translation.nllb_flores_short_map import (
    NLLB_FLORES_SHORT_TO_CODE,
    NLLB_TOKENIZER_LANGUAGE_CODES,
)


LANGUAGE_LABELS: Dict[str, str] = {
    "zh": "Chinese",
    "en": "English",
    "fi": "Finnish",
    "ru": "Russian",
    "ar": "Arabic",
    "ja": "Japanese",
    "es": "Spanish",
    "de": "German",
    "fr": "French",
    "it": "Italian",
    "pt": "Portuguese",
}


QWEN_LANGUAGE_CODES: Dict[str, str] = {
    "zh": "Chinese",
    "en": "English",
    "ru": "Russian",
    "ar": "Arabic",
    "ja": "Japanese",
    "es": "Spanish",
    "de": "German",
    "fr": "French",
    "it": "Italian",
    "pt": "Portuguese",
}


DEEPL_LANGUAGE_CODES: Dict[str, str] = {
    "zh": "ZH",
    "en": "EN",
    "ru": "RU",
    "ar": "AR",
    "ja": "JA",
    "es": "ES",
    "de": "DE",
    "fr": "FR",
    "it": "IT",
    "pt": "PT",
}


# Sparse overrides on top of ``NLLB_FLORES_SHORT_TO_CODE`` (same keys win later in
# ``build_nllb_language_catalog``). Kept for backward compatibility and explicit defaults.
NLLB_LANGUAGE_CODES: Dict[str, str] = {
    "en": "eng_Latn",
    "fi": "fin_Latn",
    "zh": "zho_Hans",
    "ru": "rus_Cyrl",
    "ar": "arb_Arab",
    "ja": "jpn_Jpan",
    "es": "spa_Latn",
    "de": "deu_Latn",
    "fr": "fra_Latn",
    "it": "ita_Latn",
    "pt": "por_Latn",
}


MARIAN_LANGUAGE_DIRECTIONS: Dict[str, Tuple[str, str]] = {
    "opus-mt-zh-en": ("zh", "en"),
    "opus-mt-en-zh": ("en", "zh"),
}


NLLB_LANGUAGE_ALIASES: Dict[str, str] = {
    "fi_fi": "fi",
    "fin": "fi",
    "fin_fin": "fi",
    "zh_cn": "zh",
    "zh_hans": "zh",
}


def normalize_language_key(language: Optional[str]) -> str:
    return str(language or "").strip().lower().replace("-", "_")


@lru_cache(maxsize=1)
def _nllb_tokenizer_code_by_normalized_key() -> Dict[str, str]:
    """Map lowercased ``deu_latn``-style keys to canonical tokenizer strings (e.g. ``deu_Latn``)."""
    return {normalize_language_key(code): code for code in NLLB_TOKENIZER_LANGUAGE_CODES}


def build_nllb_language_catalog(
    overrides: Optional[Mapping[str, str]] = None,
) -> Dict[str, str]:
    catalog: Dict[str, str] = {}
    for key, value in NLLB_FLORES_SHORT_TO_CODE.items():
        normalized_key = normalize_language_key(key)
        if normalized_key:
            catalog[normalized_key] = str(value).strip()
    for key, value in NLLB_LANGUAGE_CODES.items():
        normalized_key = normalize_language_key(key)
        if normalized_key:
            catalog[normalized_key] = str(value).strip()
    for key, value in (overrides or {}).items():
        normalized_key = normalize_language_key(key)
        if normalized_key:
            catalog[normalized_key] = str(value).strip()
    return catalog


def resolve_nllb_language_code(
    language: Optional[str],
    language_codes: Optional[Mapping[str, str]] = None,
) -> Optional[str]:
    normalized = normalize_language_key(language)
    if not normalized:
        return None

    catalog = build_nllb_language_catalog(language_codes)
    direct = catalog.get(normalized)
    if direct is not None:
        return direct

    alias = NLLB_LANGUAGE_ALIASES.get(normalized)
    if alias is not None:
        aliased = catalog.get(normalize_language_key(alias))
        if aliased is not None:
            return aliased

    tokenizer_hit = _nllb_tokenizer_code_by_normalized_key().get(normalized)
    if tokenizer_hit is not None:
        return tokenizer_hit

    for code in catalog.values():
        if normalize_language_key(code) == normalized:
            return code
    return None