# -*- coding: utf-8 -*-
"""Fournisseur Anthropic (API Claude)."""

import base64
import copy
import os

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

NOM = "anthropic"
ETIQUETTE = "Anthropic — Claude"
CLE_ENV = "ANTHROPIC_API_KEY"
PAQUET = "anthropic"
CONSOLE = "console.anthropic.com"
PREFIXE_CLE = "sk-ant-"

MODELE_DEFAUT = os.environ.get("PLATEFORME_MODELE_ANTHROPIC", "claude-opus-5")

# Dollars par million de jetons. À ajuster si la grille bouge.
TARIFS = {"entree": 5.0, "sortie": 25.0, "cache_lecture": 0.50, "cache_ecriture": 6.25}

MAX_JETONS = int(os.environ.get("PLATEFORME_MAX_JETONS", "64000"))
EFFORT = os.environ.get("PLATEFORME_EFFORT", "high")

# Blocs qui acceptent un point de reprise du cache.
_CACHABLES = {"text", "tool_result", "document", "image"}


def _sdk():
    import anthropic
    return anthropic


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


_CLIENTS = {}


def _client():
    cle = os.environ.get(CLE_ENV, "")
    if cle not in _CLIENTS:
        _CLIENTS[cle] = _sdk().Anthropic(max_retries=3)
    return _CLIENTS[cle]


def modeles(cle=None):
    return [m.id for m in _client().models.list()]


def essai(modele=None):
    reponse = _client().messages.create(
        model=modele or MODELE_DEFAUT, max_tokens=16,
        messages=[{"role": "user", "content": "Réponds exactement : prêt"}],
    )
    return "".join(b.text for b in reponse.content if b.type == "text").strip()


# --- Blocs de contenu -------------------------------------------------------

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


def bloc_document(chemin, titre=None):
    with open(chemin, "rb") as f:
        donnees = base64.standard_b64encode(f.read()).decode("ascii")
    return {
        "type": "document",
        "source": {"type": "base64", "media_type": "application/pdf", "data": donnees},
        "title": titre or os.path.basename(chemin),
    }


def bloc_image(chemin, type_mime):
    with open(chemin, "rb") as f:
        donnees = base64.standard_b64encode(f.read()).decode("ascii")
    return {"type": "image",
            "source": {"type": "base64", "media_type": type_mime, "data": donnees}}


def marquer_cache(bloc, duree=None):
    """Pose un point de reprise du cache sur un bloc, si son type l'accepte."""
    if isinstance(bloc, dict) and bloc.get("type") in _CACHABLES:
        bloc["cache_control"] = (
            {"type": "ephemeral", "ttl": duree} if duree else {"type": "ephemeral"}
        )
        return True
    return False


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

def conversation_initiale(systeme, blocs, modele=None):
    entete = {"type": "text", "text": systeme}
    marquer_cache(entete, "1h")
    return {
        "fournisseur": NOM,
        "modele": modele or MODELE_DEFAUT,
        "systeme": [entete],
        "messages": [{"role": "user", "content": blocs}],
    }


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


def ajouter_tour(conversation, tour):
    conversation["messages"].append({"role": "assistant", "content": tour.contenu})


def ajouter_resultats(conversation, resultats):
    """resultats : [{"appel", "contenu", "erreur"}].

    Chaque appel d'outil doit recevoir son résultat, y compris en erreur :
    une conversation où il en manque un est refusée par l'API au tour suivant.
    """
    blocs = []
    for r in resultats:
        bloc = {"type": "tool_result", "tool_use_id": r["appel"]["id"],
                "content": r["contenu"]}
        if r.get("erreur"):
            bloc["is_error"] = True
        blocs.append(bloc)
    conversation["messages"].append({"role": "user", "content": blocs})


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

def _messages_pour_requete(messages):
    """Copie la conversation en y ajoutant le point de reprise glissant.

    Le système et le brief initial sont marqués une fois pour toutes. Ce
    troisième point, posé sur le dernier message, fait que le tour suivant
    relira en cache tout ce qui précède. Il n'est jamais enregistré sur
    disque : il est recalculé à chaque requête.
    """
    messages = copy.deepcopy(messages)
    for message in reversed(messages):
        contenu = message.get("content")
        if isinstance(contenu, list) and contenu and marquer_cache(contenu[-1]):
            break
    return messages


def _usage(reponse):
    u = reponse.usage
    return {
        "entree": getattr(u, "input_tokens", 0) or 0,
        "sortie": getattr(u, "output_tokens", 0) or 0,
        "cache_lecture": getattr(u, "cache_read_input_tokens", 0) or 0,
        "cache_ecriture": getattr(u, "cache_creation_input_tokens", 0) or 0,
    }


def _outils_natifs(outils):
    return outils  # le schéma générique est déjà au format Anthropic


def appeler(conversation, outils):
    with _client().messages.stream(
        model=conversation.get("modele") or MODELE_DEFAUT,
        max_tokens=MAX_JETONS,
        system=conversation["systeme"],
        messages=_messages_pour_requete(conversation["messages"]),
        tools=_outils_natifs(outils),
        thinking={"type": "adaptive"},
        output_config={"effort": EFFORT},
    ) as flux:
        reponse = flux.get_final_message()

    appels = [
        {"id": b.id, "nom": b.name, "entree": b.input or {}}
        for b in reponse.content if b.type == "tool_use"
    ]
    texte = "\n".join(b.text for b in reponse.content
                      if b.type == "text" and b.text).strip()

    if reponse.stop_reason == "refusal":
        details = getattr(reponse, "stop_details", None)
        arret, motif = REFUS, (getattr(details, "explanation", None) or "motif non précisé")
    elif reponse.stop_reason == "max_tokens":
        arret, motif = TRONQUE, ""
    elif appels:
        arret, motif = OUTILS, ""
    else:
        arret, motif = FIN, ""

    return Tour(
        arret=arret, texte=texte, appels=appels,
        # Ré-enregistré tel quel : les blocs de réflexion doivent revenir au
        # modèle inchangés au tour suivant.
        contenu=reponse.to_dict()["content"],
        usage=_usage(reponse), motif=motif,
    )
