"""
Generateur de fichier JSON pour les traductions frontend

Ce module genere un fichier dictionnaire.json contenant toutes les traductions
stockees dans le modele Dictionnaire. Le fichier est regenere automatiquement
lorsque des donnees sont ajoutees, modifiees ou supprimees.

Structure du fichier JSON:
{
    "meta": {
        "generated_at": "2024-01-15T10:30:00",
        "languages": ["fr", "en", "de", "es", "it"],
        "default_language": "fr"
    },
    "translations": {
        "en": {
            "news.newsarticle": {
                "1": {
                    "title": "Title in English",
                    "content": "Content..."
                }
            }
        },
        "de": { ... }
    }
}
"""

import json
import os
from datetime import datetime
from django.conf import settings
from django.contrib.contenttypes.models import ContentType


def get_dictionary_path():
    """Retourne le chemin du fichier dictionnaire.json"""
    static_dir = os.path.join(settings.BASE_DIR, 'static', 'translations')
    os.makedirs(static_dir, exist_ok=True)
    return os.path.join(static_dir, 'dictionnaire.json')


def generate_dictionary_json():
    """
    Genere le fichier dictionnaire.json avec toutes les traductions

    Returns:
        str: Chemin du fichier genere
    """
    from .models import Language, Dictionnaire

    # Recuperer les langues actives
    languages = Language.objects.filter(is_active=True).order_by('order')
    default_lang = Language.get_default()

    # Structure du dictionnaire
    dictionary = {
        "meta": {
            "generated_at": datetime.now().isoformat(),
            "languages": [lang.code for lang in languages],
            "default_language": default_lang.code if default_lang else "fr",
            "language_names": {lang.code: lang.name for lang in languages}
        },
        "translations": {}
    }

    # Recuperer toutes les traductions
    translations = Dictionnaire.objects.select_related(
        'language', 'content_type'
    ).filter(
        language__is_active=True
    ).order_by('language__code', 'content_type__app_label', 'content_type__model', 'object_id')

    # Organiser par langue > app.model > object_id > field
    for trans in translations:
        lang_code = trans.language.code
        model_key = f"{trans.content_type.app_label}.{trans.content_type.model}"
        obj_id = str(trans.object_id)

        if lang_code not in dictionary["translations"]:
            dictionary["translations"][lang_code] = {}

        if model_key not in dictionary["translations"][lang_code]:
            dictionary["translations"][lang_code][model_key] = {}

        if obj_id not in dictionary["translations"][lang_code][model_key]:
            dictionary["translations"][lang_code][model_key][obj_id] = {}

        dictionary["translations"][lang_code][model_key][obj_id][trans.field] = trans.translation

    # Ecrire le fichier
    filepath = get_dictionary_path()
    with open(filepath, 'w', encoding='utf-8') as f:
        json.dump(dictionary, f, ensure_ascii=False, indent=2)

    return filepath


def generate_dictionary_js():
    """
    Genere un fichier JavaScript avec les traductions pour utilisation directe

    Returns:
        str: Chemin du fichier genere
    """
    from .models import Language, Dictionnaire

    # Recuperer les langues actives
    languages = Language.objects.filter(is_active=True).order_by('order')
    default_lang = Language.get_default()

    # Recuperer toutes les traductions groupees par langue
    translations_by_lang = {}

    translations = Dictionnaire.objects.select_related(
        'language', 'content_type'
    ).filter(
        language__is_active=True
    )

    for trans in translations:
        lang_code = trans.language.code
        model_key = f"{trans.content_type.app_label}.{trans.content_type.model}"
        key = f"{model_key}.{trans.object_id}.{trans.field}"

        if lang_code not in translations_by_lang:
            translations_by_lang[lang_code] = {}

        translations_by_lang[lang_code][key] = trans.translation

    # Creer le contenu JavaScript
    js_content = f"""/**
 * Dictionnaire de traductions - Genere automatiquement
 * Date: {datetime.now().isoformat()}
 * Ne pas modifier ce fichier manuellement
 */

window.EUROMA_TRANSLATIONS = {{
    meta: {{
        languages: {json.dumps([lang.code for lang in languages])},
        defaultLanguage: "{default_lang.code if default_lang else 'fr'}",
        languageNames: {json.dumps({lang.code: lang.name for lang in languages}, ensure_ascii=False)}
    }},
    data: {json.dumps(translations_by_lang, ensure_ascii=False, indent=4)}
}};

/**
 * Recupere une traduction
 * @param {{string}} key - Cle de traduction (ex: "news.newsarticle.1.title")
 * @param {{string}} lang - Code langue (optionnel, utilise la langue courante par defaut)
 * @param {{string}} fallback - Valeur par defaut si traduction non trouvee
 * @returns {{string}} Traduction ou fallback
 */
window.getTranslation = function(key, lang, fallback) {{
    lang = lang || document.documentElement.lang || EUROMA_TRANSLATIONS.meta.defaultLanguage;

    if (EUROMA_TRANSLATIONS.data[lang] && EUROMA_TRANSLATIONS.data[lang][key]) {{
        return EUROMA_TRANSLATIONS.data[lang][key];
    }}

    // Fallback vers la langue par defaut
    var defaultLang = EUROMA_TRANSLATIONS.meta.defaultLanguage;
    if (lang !== defaultLang && EUROMA_TRANSLATIONS.data[defaultLang] && EUROMA_TRANSLATIONS.data[defaultLang][key]) {{
        return EUROMA_TRANSLATIONS.data[defaultLang][key];
    }}

    return fallback || key;
}};

/**
 * Recupere toutes les traductions pour un objet
 * @param {{string}} modelKey - Cle du modele (ex: "news.newsarticle")
 * @param {{string|number}} objectId - ID de l'objet
 * @param {{string}} lang - Code langue (optionnel)
 * @returns {{object}} Objet avec les champs traduits
 */
window.getObjectTranslations = function(modelKey, objectId, lang) {{
    lang = lang || document.documentElement.lang || EUROMA_TRANSLATIONS.meta.defaultLanguage;
    var result = {{}};
    var prefix = modelKey + "." + objectId + ".";

    var langData = EUROMA_TRANSLATIONS.data[lang] || {{}};
    for (var key in langData) {{
        if (key.startsWith(prefix)) {{
            var field = key.substring(prefix.length);
            result[field] = langData[key];
        }}
    }}

    return result;
}};
"""

    # Ecrire le fichier
    static_dir = os.path.join(settings.BASE_DIR, 'static', 'translations')
    os.makedirs(static_dir, exist_ok=True)
    filepath = os.path.join(static_dir, 'dictionnaire.js')

    with open(filepath, 'w', encoding='utf-8') as f:
        f.write(js_content)

    return filepath


def regenerate_all():
    """Regenere tous les fichiers de traduction"""
    json_path = generate_dictionary_json()
    js_path = generate_dictionary_js()
    return {
        'json': json_path,
        'js': js_path
    }