from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI

from base_de_donnees_vectorielle.embeddings import charger_modele
from base_de_donnees_vectorielle.requeteur import rechercher
from base_de_donnees_vectorielle.stockage import charger_base
from base_de_donnees_vectorielle.modele import ResultatRecherche


CHEMIN_BASE = "db/vector_db.json"
TOP_K = 3
SEUIL_RECHERCHE = 0.4

BASE_VECTORIELLE = charger_base(CHEMIN_BASE)
MODELE_EMBEDDINGS = charger_modele()

def recuperer_contexte(question: str,
                       base: list[ResultatRecherche] = BASE_VECTORIELLE,
                       modele: object = MODELE_EMBEDDINGS,
                       top_k: int = TOP_K,
                       seuil: float = SEUIL_RECHERCHE) -> list[ResultatRecherche]:
    """
    Recherche les chunks les plus pertinents dans la base vectorielle
    pour répondre à une question.

    :param question: Question posée par l'utilisateur.
    :param base: Base vectorielle à interroger.
    :param modele: Modèle d'embeddings utilisé pour calculer les similarités.
    :param top_k: Nombre maximal de chunks à retourner.
    :param seuil: Score minimal de similarité.
    :return: Liste des résultats de recherche.
    """
    return []


def construire_contexte(resultats: list[ResultatRecherche]) -> str:
    """
    Transforme les résultats de recherche en un contexte textuel
    injecté dans le prompt du LLM.

    Chaque chunk est numéroté et accompagné de sa source pour permettre
    au modèle de s'appuyer sur des éléments identifiables.

    :param resultats: Résultats retournés par la recherche sémantique.
    :return: Texte de contexte prêt à être injecté dans le prompt.
    """
    return ""


def construire_messages(question: str, contexte: str) -> list[SystemMessage, HumanMessage]:
    """
    Construit les messages envoyés au LLM.

    On utilise :
    - un message système pour fixer le comportement du chatbot ;
    - un message humain contenant la question et le contexte retrouvé.

    :param question: Question de l'utilisateur.
    :param contexte: Contexte documentaire issu de la recherche.
    :return: Liste de messages LangChain.
    """
    return [None, None]


def generer_reponse(question: str,
                    llm: ChatOpenAI,
                    top_k: int = TOP_K,
                    seuil: float = SEUIL_RECHERCHE) -> tuple[str, list[ResultatRecherche]]:
    """
    Exécute toute la chaîne RAG :
    1. recherche des chunks pertinents ;
    2. construction du contexte ;
    3. appel du LLM ;
    4. retour de la réponse et des sources utilisées.

    :param question: Question de l'utilisateur.
    :param llm: Instance du modèle de chat.
    :param top_k: Nombre maximal de chunks utilisés.
    :param seuil: Seuil minimal de similarité.
    :return: Un tuple (texte_reponse, resultats_recherche).
    """
    rreturn "", []


def afficher_sources(resultats: list[ResultatRecherche]) -> None:
    """
    Affiche les sources documentaires utilisées pour générer la réponse.

    :param resultats: Résultats de recherche ayant servi au contexte.
    """


def chatbot(modele: str, url_llm: str, cle_llm: str) -> None:
    """
    Lance un chatbot interactif utilisant une approche RAG.

    Le chatbot :
    - charge un LLM distant ;
    - attend une question utilisateur ;
    - recherche les chunks les plus pertinents dans la base vectorielle ;
    - construit un prompt enrichi avec le contexte ;
    - demande au LLM de produire la réponse finale.

    :param modele: Nom du modèle du LLM.
    :param url_llm: URL du serveur compatible OpenAI.
    :param cle_llm: Clé API du serveur LLM.
    """
    llm = ChatOpenAI(
        model=modele,
        base_url=url_llm,
        api_key=cle_llm,
    )

    print("Chatbot RAG prêt. Tape 'exit' ou 'quit' pour terminer.")

    while True:
        user_input = input(">>> ").strip()

        if not user_input:
            continue

        if user_input.lower() in ["exit", "quit"]:
            print("Fin.")
            break

        try:
            reponse, sources = generer_reponse(
                question=user_input,
                llm=llm,
            )

            print("\nRéponse finale")
            print(reponse)
            print()
            afficher_sources(sources)
            print()

        except FileNotFoundError:
            print(
                "\nErreur : base vectorielle introuvable. "
                "Il faut d'abord exécuter la commande 'indexer'.\n"
            )
        except Exception as e:
            print("\nErreur :", e)
            print()
