# -*- coding: utf-8 -*-
"""
Fournisseur Google (API Gemini).

Le nom du modèle n'est pas figé dans le code : les catalogues bougent plus
vite que les fichiers. `PLATEFORME_MODELE_GEMINI` le surcharge, et le
vérificateur d'installation liste ceux que votre clé donne réellement.
"""

import os

from .base import FIN, OUTILS, REFUS, TRONQUE, Tour

NOM = "gemini"
ETIQUETTE = "Google — Gemini"
CLE_ENV = "GEMINI_API_KEY"
PAQUET = "google-genai"
CONSOLE = "aistudio.google.com/apikey"
PREFIXE_CLE = ""  # les clés Google n'ont pas de préfixe stable

MODELE_DEFAUT = os.environ.get("PLATEFORME_MODELE_GEMINI", "gemini-2.5-pro")

# Dollars par million de jetons. À vérifier sur ai.google.dev/pricing :
# la grille dépend du modèle et de la taille du contexte.
TARIFS = {"entree": 1.25, "sortie": 10.0, "cache_lecture": 0.31, "cache_ecriture": 0.0}

MAX_JETONS = int(os.environ.get("PLATEFORME_MAX_JETONS_GEMINI", "32000"))

# Fins de génération qui signalent un blocage, pas une réponse.
_REFUS = {
    "SAFETY", "PROHIBITED_CONTENT", "BLOCKLIST", "SPII", "RECITATION",
    "IMAGE_SAFETY", "IMAGE_PROHIBITED_CONTENT", "IMAGE_RECITATION", "LANGUAGE",
}
# Fins qui valent « recommence », pas « abandonne ».
_TRONQUE = {"MAX_TOKENS", "MALFORMED_FUNCTION_CALL", "UNEXPECTED_TOOL_CALL",
            "TOO_MANY_TOOL_CALLS"}


def _sdk():
    from google import genai
    from google.genai import types
    return genai, types


def disponible():
    try:
        _sdk()
        return True, "installé"
    except ImportError:
        return False, "paquet « google-genai » absent — pip install google-genai"


# Le client porte la connexion HTTP. Un client neuf à chaque appel est
# ramassé par le glaneur au milieu de la requête — « Cannot send a request,
# as the client has been closed ». On le garde, indexé par la clé.
_CLIENTS = {}


def _taire_avertissement_afc():
    """Éteint le message du SDK sur l'exécution automatique des fonctions.

    Il conseille d'utiliser Chat.send_message ; ici la boucle d'outils est
    la nôtre, et l'exécution automatique est justement désactivée. Le message
    n'apporte rien et pollue worker.log à chaque tour.
    """
    import logging

    class _Filtre(logging.Filter):
        def filter(self, enregistrement):
            return "automatic function calling" not in enregistrement.getMessage().lower()

    journal = logging.getLogger("google_genai.models")
    if not any(isinstance(f, _Filtre) for f in journal.filters):
        journal.addFilter(_Filtre())


def _client():
    genai, _ = _sdk()
    cle = os.environ.get(CLE_ENV)
    if not cle:
        raise RuntimeError("%s absente du .env" % CLE_ENV)
    if cle not in _CLIENTS:
        _taire_avertissement_afc()
        _CLIENTS[cle] = genai.Client(api_key=cle)
    return _CLIENTS[cle]


def modeles(cle=None):
    noms = []
    for m in list(_client().models.list()):
        nom = (getattr(m, "name", "") or "").replace("models/", "")
        actions = getattr(m, "supported_actions", None)
        if nom and (actions is None or "generateContent" in actions):
            noms.append(nom)
    return noms


def essai(modele=None):
    reponse = _client().models.generate_content(
        model=modele or MODELE_DEFAUT,
        contents="Réponds exactement : prêt",
    )
    return (reponse.text or "").strip()


# --- Blocs de contenu -------------------------------------------------------
# On enregistre des dictionnaires (format JSON de Part), pas des objets :
# la conversation doit survivre sur disque entre deux passages du worker.

def bloc_texte(texte):
    return {"text": texte}


def _inline(chemin, type_mime):
    import base64
    with open(chemin, "rb") as f:
        donnees = base64.standard_b64encode(f.read()).decode("ascii")
    return {"inline_data": {"mime_type": type_mime, "data": donnees}}


def bloc_document(chemin, titre=None):
    return _inline(chemin, "application/pdf")


def bloc_image(chemin, type_mime):
    return _inline(chemin, type_mime)


def marquer_cache(bloc, duree=None):
    """Sans objet : Gemini met en cache le préfixe automatiquement.

    On ne pose donc aucun marqueur — mais il faut que le début de la
    conversation reste identique d'un tour à l'autre, ce que garantit
    l'ordre des blocs choisi dans prompt.py.
    """
    return False


# --- Conversation -----------------------------------------------------------

def conversation_initiale(systeme, blocs, modele=None):
    return {
        "fournisseur": NOM,
        "modele": modele or MODELE_DEFAUT,
        "systeme": systeme,
        "messages": [{"role": "user", "parts": blocs}],
    }


def ajouter_texte_utilisateur(conversation, texte):
    conversation["messages"].append({"role": "user", "parts": [bloc_texte(texte)]})


def ajouter_tour(conversation, tour):
    # Les parties de réflexion portent une signature que le modèle doit
    # retrouver telle quelle : on ré-enregistre sans rien filtrer.
    conversation["messages"].append({"role": "model", "parts": tour.contenu})


def ajouter_resultats(conversation, resultats):
    """resultats : [{"appel", "contenu", "erreur"}]."""
    parts = []
    for r in resultats:
        appel = r["appel"]
        reponse = ({"error": r["contenu"]} if r.get("erreur")
                   else {"resultat": r["contenu"]})
        fonction = {"name": appel["nom"], "response": reponse}
        # L'identifiant n'est renvoyé que si le modèle en a fourni un ;
        # sinon l'appariement se fait par nom.
        if appel.get("id_natif"):
            fonction["id"] = appel["id_natif"]
        parts.append({"function_response": fonction})
    conversation["messages"].append({"role": "user", "parts": parts})


# --- Appel ------------------------------------------------------------------

def _outils_natifs(outils, types):
    declarations = [
        types.FunctionDeclaration(
            name=o["name"],
            description=o["description"],
            parameters_json_schema=o["input_schema"],
        )
        for o in outils
    ]
    return [types.Tool(function_declarations=declarations)]


def _usage(reponse):
    u = getattr(reponse, "usage_metadata", None)
    if not u:
        return {"entree": 0, "sortie": 0, "cache_lecture": 0, "cache_ecriture": 0}
    cache = getattr(u, "cached_content_token_count", 0) or 0
    total_entree = getattr(u, "prompt_token_count", 0) or 0
    sortie = getattr(u, "candidates_token_count", 0) or 0
    # Les jetons de réflexion sont facturés en sortie mais comptés à part.
    sortie += getattr(u, "thoughts_token_count", 0) or 0
    return {
        # prompt_token_count inclut le cache : on retranche pour ne pas
        # facturer deux fois la même chose.
        "entree": max(total_entree - cache, 0),
        "sortie": sortie,
        "cache_lecture": cache,
        "cache_ecriture": 0,
    }


def appeler(conversation, outils):
    _, types = _sdk()
    config = types.GenerateContentConfig(
        system_instruction=conversation["systeme"],
        tools=_outils_natifs(outils, types),
        max_output_tokens=MAX_JETONS,
        # Le SDK exécuterait de lui-même les fonctions Python qu'on lui
        # passerait. Ici les outils sont de simples déclarations : c'est le
        # moteur qui les exécute, et lui seul.
        automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True),
        thinking_config=types.ThinkingConfig(include_thoughts=True),
    )
    reponse = _client().models.generate_content(
        model=conversation.get("modele") or MODELE_DEFAUT,
        contents=[types.Content.model_validate(m) for m in conversation["messages"]],
        config=config,
    )

    candidats = getattr(reponse, "candidates", None) or []
    if not candidats:
        retour = getattr(reponse, "prompt_feedback", None)
        return Tour(arret=REFUS, contenu=[], usage=_usage(reponse),
                    motif="requête bloquée en amont (%s)" % (retour or "sans détail"))

    candidat = candidats[0]
    parts = (getattr(candidat.content, "parts", None) or []) if candidat.content else []
    contenu = [p.model_dump(mode="json", exclude_none=True) for p in parts]

    appels, texte = [], []
    for rang, part in enumerate(parts):
        if part.function_call is not None:
            appel = part.function_call
            appels.append({
                "id": appel.id or ("appel-%d-%d" % (len(conversation["messages"]), rang)),
                "id_natif": appel.id,
                "nom": appel.name,
                "entree": dict(appel.args or {}),
            })
        elif part.text and not getattr(part, "thought", False):
            texte.append(part.text)

    raison = getattr(candidat, "finish_reason", None)
    raison = getattr(raison, "name", None) or str(raison or "")

    if raison in _REFUS:
        arret = REFUS
        motif = getattr(candidat, "finish_message", None) or raison
    elif raison in _TRONQUE:
        arret, motif = TRONQUE, ""
    elif appels:
        arret, motif = OUTILS, ""
    else:
        arret, motif = FIN, ""

    return Tour(arret=arret, texte="\n".join(texte).strip(), appels=appels,
                contenu=contenu, usage=_usage(reponse), motif=motif)
