# -*- coding: utf-8 -*-
"""
Le moteur : un tour de dialogue, quel que soit le fournisseur.

Ce module ne connaît aucun SDK. Il charge la conversation, demande un tour au
fournisseur du projet, exécute les outils, ré-enregistre, et rend la main. Le
worker l'appelle en boucle tant qu'il lui reste du temps.

Ce découpage est ce qui permet de tourner sur un hébergement mutualisé :
aucun processus ne vit longtemps, et une interruption ne coûte qu'un tour.
"""

import config
import fournisseurs
import outils
import projets
from fournisseurs.base import FIN, OUTILS, REFUS, TRONQUE

# Nombre de relances avant de considérer qu'un modèle qui s'arrête sans
# appeler terminer() a bel et bien fini.
MAX_RELANCES = 2

MESSAGE_TRONQUE = (
    "Réponse tronquée : ce fichier dépasse ce qui tient en un tour. Écris-le "
    "en plusieurs fichiers plus petits, ou écris d'abord une partie puis "
    "complète."
)
MESSAGE_RELANCE = (
    "Si le travail demandé est terminé, appelle l'outil terminer avec ton "
    "résumé de livraison. Sinon, poursuis l'écriture des fichiers."
)


def fournisseur_de(conversation):
    return fournisseurs.module(conversation.get("fournisseur") or config.FOURNISSEUR)


def un_tour(projet_id):
    """Fait avancer le projet d'un tour.

    Renvoie ("continuer"|"termine"|"echec", détail). Le worker s'arrête sur
    autre chose que "continuer".
    """
    conversation = projets.lire_conversation(projet_id)
    if not conversation:
        return "echec", "Conversation absente : le projet n'a pas été préparé."
    if not conversation.get("messages"):
        return "echec", "Conversation vide."

    projet = projets.lire(projet_id)
    if projet and projet["tours"] >= config.MAX_TOURS:
        return "echec", (
            "Plafond de %d tours atteint sans que le modèle appelle terminer(). "
            "Génération abandonnée." % config.MAX_TOURS
        )

    fournisseur = fournisseur_de(conversation)
    tour = fournisseur.appeler(conversation, outils.OUTILS)

    projets.compter_tour(projet_id, tour.usage)
    projets.compter_echec(projet_id, remise_a_zero=True)

    if tour.texte:
        projets.journaliser(projet_id, "message", tour.texte[:2000])

    # --- Refus --------------------------------------------------------------
    if tour.arret == REFUS:
        if tour.contenu:
            fournisseur.ajouter_tour(conversation, tour)
            projets.ecrire_conversation(projet_id, conversation)
        return "echec", "Génération déclinée par le modèle (%s)." % (
            tour.motif or "motif non précisé")

    fournisseur.ajouter_tour(conversation, tour)

    # --- Réponse tronquée ---------------------------------------------------
    if tour.arret == TRONQUE:
        if tour.appels:
            # Un appel d'outil tronqué n'est pas exécutable, mais il doit
            # quand même recevoir un résultat, sinon la conversation devient
            # invalide. On répond en erreur.
            fournisseur.ajouter_resultats(conversation, [
                {"appel": appel, "contenu": MESSAGE_TRONQUE, "erreur": True}
                for appel in tour.appels
            ])
        else:
            fournisseur.ajouter_texte_utilisateur(conversation, "Réponse tronquée, poursuis.")
        projets.ecrire_conversation(projet_id, conversation)
        projets.journaliser(projet_id, "tronque", "réponse coupée")
        return "continuer", "réponse tronquée, relance"

    # --- Le modèle s'arrête sans appeler terminer() -------------------------
    if tour.arret == FIN or not tour.appels:
        relances = conversation.get("relances", 0) + 1
        conversation["relances"] = relances
        if relances > MAX_RELANCES:
            projets.ecrire_conversation(projet_id, conversation)
            return "termine", tour.texte or "Le modèle s'est arrêté."
        fournisseur.ajouter_texte_utilisateur(conversation, MESSAGE_RELANCE)
        projets.ecrire_conversation(projet_id, conversation)
        return "continuer", "relance (%d/%d)" % (relances, MAX_RELANCES)

    # --- Exécution des outils ----------------------------------------------
    conversation["relances"] = 0
    resultats = []
    fini = None
    racine_site = projets.dossier_site(projet_id)

    for appel in tour.appels:
        texte, erreur = outils.executer(racine_site, appel["nom"], appel["entree"])
        resultats.append({"appel": appel, "contenu": texte, "erreur": erreur})

        if appel["nom"] == "ecrire_fichier":
            projets.journaliser(projet_id, "erreur_outil" if erreur else "fichier", texte[:500])
        elif appel["nom"] == "terminer" and not erreur:
            fini = (appel["entree"] or {}).get("resume") or tour.texte
            projets.journaliser(projet_id, "termine", (fini or "")[:2000])
        elif erreur:
            projets.journaliser(projet_id, "erreur_outil", texte[:500])

    fournisseur.ajouter_resultats(conversation, resultats)
    projets.ecrire_conversation(projet_id, conversation)

    if fini is not None:
        return "termine", fini
    return "continuer", "%d appel(s) d'outil" % len(tour.appels)


def relancer(projet_id, consigne):
    """Ajoute une consigne à une conversation terminée et la remet en file.

    C'est tout le mécanisme des itérations et des annexes : « refais la
    section chiffres », « crée la page Exposants », « convertis en Elementor »
    sont des messages de plus dans le même dialogue, qui a déjà tout le
    contexte.
    """
    conversation = projets.lire_conversation(projet_id)
    if not conversation:
        raise ValueError("Projet sans conversation.")
    fournisseur_de(conversation).ajouter_texte_utilisateur(conversation, consigne)
    conversation["relances"] = 0
    projets.ecrire_conversation(projet_id, conversation)
    projets.journaliser(projet_id, "consigne", consigne[:2000])
    projets.changer_etat(projet_id, projets.EN_ATTENTE)
