# -*- coding: utf-8 -*-
"""Le contrat des fournisseurs : même scénario, deux SDK, un seul Tour."""

import os
import shutil
import sys
import tempfile

BASE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, BASE); sys.path.insert(0, os.path.join(BASE, "tests"))
_BAC = tempfile.mkdtemp(prefix="plateforme-fourn-")
os.environ["PLATEFORME_PROJETS"] = os.path.join(_BAC, "projets")
os.environ["PLATEFORME_BASE"] = os.path.join(_BAC, "x.db")
os.environ.setdefault("GEMINI_API_KEY", "cle-factice-pour-les-tests")

import fournisseurs, outils
import faux_client as fc
from fournisseurs.base import FIN, OUTILS, REFUS, TRONQUE

OK = [0, 0]
def v(c, l):
    OK[0 if c else 1] += 1
    print("  %s %s" % ("ok  " if c else "ECHEC", l))

ECRITURE = ("ecrire_fichier", {"chemin": "assets/css/style.css", "contenu": "body{}"})

for nom in fournisseurs.CONNUS:
    module = fournisseurs.module(nom)
    print("\n=== %s ===" % module.ETIQUETTE)

    # --- le contrat est-il complet ? ---
    manquants = [a for a in ("NOM", "ETIQUETTE", "CLE_ENV", "PAQUET", "MODELE_DEFAUT",
                             "TARIFS", "disponible", "modeles", "essai", "bloc_texte",
                             "bloc_document", "bloc_image", "marquer_cache",
                             "conversation_initiale", "ajouter_texte_utilisateur",
                             "appeler", "ajouter_tour", "ajouter_resultats")
                 if not hasattr(module, a)]
    v(not manquants, "contrat complet%s" % (" — manque %s" % manquants if manquants else ""))
    v(set(module.TARIFS) == {"entree", "sortie", "cache_lecture", "cache_ecriture"},
      "tarifs aux quatre postes")

    conv = module.conversation_initiale("Tu es DA.", [module.bloc_texte("Brief")])
    v(conv["fournisseur"] == nom, "le fournisseur est inscrit dans la conversation")
    v(bool(conv.get("modele")), "le modèle est épinglé : %s" % conv["modele"])

    # --- appels d'outils ---
    faux = fc.brancher(nom, [
        fc.Etape(texte="Charte retenue.", appels=[ECRITURE], reflexion=True),
        fc.Etape(texte="Terminé.", arret="fin"),
        fc.Etape(appels=[ECRITURE], arret="tronque"),
        fc.Etape(arret="refus"),
        fc.Etape(appels=[ECRITURE, ("lire_fichier", {"chemin": "index.html"})]),
    ])

    tour = module.appeler(conv, outils.OUTILS)
    v(tour.arret == OUTILS, "appel d'outil → arret=%s" % tour.arret)
    v(tour.texte == "Charte retenue.", "texte visible extrait (%r)" % tour.texte[:30])
    v(len(tour.appels) == 1 and tour.appels[0]["nom"] == "ecrire_fichier",
      "appel décodé : %s" % (tour.appels[0]["nom"] if tour.appels else "aucun"))
    v(tour.appels[0]["entree"].get("chemin") == "assets/css/style.css",
      "arguments décodés : %r" % tour.appels[0]["entree"].get("chemin"))
    v(bool(tour.appels[0].get("id")), "identifiant d'appel présent")
    v(tour.usage["entree"] == fc.JETONS["entree"], "jetons d'entrée hors cache : %d"
      % tour.usage["entree"])
    v(tour.usage["cache_lecture"] == fc.JETONS["cache"], "jetons lus en cache : %d"
      % tour.usage["cache_lecture"])
    v(tour.usage["sortie"] == fc.JETONS["sortie"], "jetons de sortie : %d" % tour.usage["sortie"])

    # la réflexion doit être ré-enregistrée telle quelle
    module.ajouter_tour(conv, tour)
    brut = str(conv["messages"][-1])
    v("sig" in brut.lower() or "thought" in brut.lower() or "thinking" in brut.lower(),
      "trace de réflexion conservée pour le tour suivant")

    module.ajouter_resultats(conv, [
        {"appel": tour.appels[0], "contenu": "Écrit : style.css", "erreur": False}])
    v(len(conv["messages"]) == 3, "résultat d'outil ajouté")

    import json
    v(json.dumps(conv, ensure_ascii=False), "conversation sérialisable en JSON")

    # --- fin, troncature, refus ---
    v(module.appeler(conv, outils.OUTILS).arret == FIN, "fin de tour → arret=fin")
    t = module.appeler(conv, outils.OUTILS)
    v(t.arret == TRONQUE and len(t.appels) == 1,
      "troncature → arret=tronque, appel conservé pour lui répondre en erreur")
    t = module.appeler(conv, outils.OUTILS)
    v(t.arret == REFUS and t.motif, "refus → arret=refus, motif : %r" % t.motif[:30])

    # --- appels multiples dans un même tour ---
    t = module.appeler(conv, outils.OUTILS)
    v(len(t.appels) == 2, "deux appels dans un tour (%d)" % len(t.appels))
    v(len({a["id"] for a in t.appels}) == 2, "identifiants distincts")

    # --- la requête envoyée contient bien les outils et le système ---
    requete = faux.requetes[0]
    if nom == "anthropic":
        v(len(requete["tools"]) == 4, "4 outils transmis")
        v(requete["system"][0]["text"].startswith("Tu es DA"), "système transmis")
        v("temperature" not in requete, "aucun paramètre d'échantillonnage")
        points = sum(1 for b in requete["system"] if b.get("cache_control"))
        points += sum(1 for m in requete["messages"] if isinstance(m.get("content"), list)
                      for b in m["content"] if isinstance(b, dict) and b.get("cache_control"))
        v(0 < points <= 4, "%d point(s) de reprise du cache" % points)
    else:
        config = requete["config"]
        declarations = config.tools[0].function_declarations
        v(len(declarations) == 4, "4 déclarations de fonction transmises")
        v(declarations[0].parameters_json_schema is not None, "schéma JSON transmis")
        v(config.system_instruction.startswith("Tu es DA"), "instruction système transmise")
        v(config.automatic_function_calling.disable is True,
          "exécution automatique des fonctions désactivée")
        v(all(hasattr(c, "parts") for c in requete["contents"]),
          "contenus validés comme objets Content")

print("\n%d ok, %d échecs" % (OK[0], OK[1]))
shutil.rmtree(_BAC, ignore_errors=True)
sys.exit(1 if OK[1] else 0)
