"""
Système de traduction simple et efficace pour Web Sentinel.
Un fichier JSON par langue dans le dossier localization/.
"""

import json
import os
from pathlib import Path
from typing import Dict, Any

# Cache global pour les traductions chargées
_translation_cache: Dict[str, Dict[str, Any]] = {}
_current_language = "fr"  # Langue par défaut
AVAILABLE_LANGUAGES = ("fr", "en")

def set_language(language: str) -> None:
    """Définit la langue active."""
    global _current_language
    _current_language = language

def get_current_language() -> str:
    """Retourne la langue active."""
    return _current_language

def _load_translations(language: str) -> Dict[str, Any]:
    """Charge les traductions pour une langue donnée."""
    if language in _translation_cache:
        return _translation_cache[language]
    
    # Chemin vers le fichier de traduction
    localization_dir = Path(__file__).parent
    translation_file = localization_dir / f"{language}.json"
    
    if not translation_file.exists():
        # Si le fichier de langue n'existe pas, utiliser l'anglais par défaut
        if language != "en":
            return _load_translations("en")
        else:
            # Si même l'anglais n'existe pas, retourner un dict vide
            return {}
    
    try:
        with open(translation_file, 'r', encoding='utf-8') as f:
            translations = json.load(f)
            _translation_cache[language] = translations
            return translations
    except Exception:
        # En cas d'erreur, utiliser l'anglais ou un dict vide
        if language != "en":
            return _load_translations("en")
        return {}

def t(key: str, *args, **params) -> str:
    """
    Fonction de traduction principale.
    
    Args:
        key: Clé de traduction (ex: "sast.php.sql_injection.title")
        **params: Paramètres pour remplacer dans le texte (ex: line=42, file="test.php")
    
    Returns:
        Texte traduit avec paramètres remplacés
    """
    translations = _load_translations(_current_language)
    
    # Naviguer dans l'arbre JSON avec la clé
    keys = key.split('.')
    value = translations
    
    try:
        for k in keys:
            value = value[k]

        if isinstance(value, str):
            if args or params:
                try:
                    return value.format(*args, **params)
                except (IndexError, KeyError, ValueError):
                    return value
            return value
        return key
    except (KeyError, TypeError):
        return key

def get_available_languages() -> Dict[str, str]:
    """Retourne le libellé de chaque langue disponible."""
    labels: Dict[str, str] = {}
    for language in AVAILABLE_LANGUAGES:
        translations = _load_translations(language)
        lang_labels = translations.get("language_labels", {})
        label = lang_labels.get(language)
        if isinstance(label, str):
            labels[language] = label
        else:
            labels[language] = language.upper()
    return labels

def translate_severity(severity: str) -> str:
    """Traduit un niveau de sévérité."""
    return t(f"severity_{severity.lower()}")

def translate_module(module: str) -> str:
    """Traduit le nom d'un module."""
    sanitized = module.replace("-", "_")
    alias_map = {
        'tls': 'module_tls',
        'headers': 'module_headers',
        'static': 'module_static_analysis',
        'static_analysis': 'module_static_analysis',
        'injection': 'module_injection',
        'third_party': 'module_third_party',
        'thirdparty': 'module_third_party',
        'source_code': 'module_source_code',
        'osint': 'module_osint',
        'backend_config': 'module_backend_config',
        'api_security': 'module_api_security',
        'modern_web': 'module_modern_web',
        'access_control': 'module_access_control',
        'crypto_failures': 'module_crypto_failures',
        'vulnerable_components': 'module_vulnerable_components',
        'insecure_design': 'module_insecure_design',
        'security_misconfiguration': 'module_security_misconfig',
        'broken_authentication': 'module_auth_failures',
    }
    key = alias_map.get(sanitized, f'module_{sanitized}')
    return t(key)



def get_all_translations() -> Dict[str, Dict[str, Any]]:
    """Retourne l'ensemble des traductions pour chaque langue."""
    return {lang: _load_translations(lang) for lang in AVAILABLE_LANGUAGES}

def get_translation_dict(key: str) -> Dict[str, str]:
    """
    Retourne un dictionnaire contenant les champs localisés d'un finding.
    
    Les clés prises en charge sont au minimum title/description/remediation et
    peuvent optionnellement inclure impact et evidence. Des valeurs par défaut
    sont générées si la clé n'existe pas dans les fichiers de traduction.
    """
    translations = _load_translations(_current_language)
    
    # D'abord essayer l'accès direct à la clé complète (ex: "sast.not_configured")
    value = translations.get(key)
    
    # Si pas trouvé, essayer la navigation par points (ex: sast -> not_configured)
    if value is None:
        keys = key.split(".")
        value = translations
        try:
            for k in keys:
                value = value[k]
        except (KeyError, TypeError):
            value = None

    defaults = {
        "title": f"{key}.title",
        "description": f"{key}.description",
        "remediation": f"{key}.remediation",
    }

    if isinstance(value, dict):
        result = defaults.copy()
        for field in ("title", "description", "remediation", "impact", "evidence"):
            field_value = value.get(field)
            if isinstance(field_value, str):
                result[field] = field_value
        return result

    return defaults