app/llm_handling.py

import logging
import os
import shutil

from openai import OpenAI
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
import gradio as gr

from app.config import OPENAI_API_KEY
from app.functions.database_handling import BASE_DB_PATH  # Aggiungi questo import
from app.configs.prompts import SYSTEM_PROMPTS

logging.basicConfig(level=logging.INFO)

def get_system_prompt(prompt_type="tutor"):
    """Seleziona il prompt di sistema appropriato"""
    return SYSTEM_PROMPTS.get(prompt_type, SYSTEM_PROMPTS["tutor"])

def answer_question(question, db_name, prompt_type="tutor", chat_history=None):
    """
    Risponde alla domanda 'question' usando i documenti del database 'db_name'.
    Restituisce una lista di 2 messaggi in formato:
      [
        {"role": "user", "content": <domanda>},
        {"role": "assistant", "content": <risposta>}
      ]

    In questa versione, viene effettuato il log dei 'chunk' recuperati durante
    la ricerca di similarità.
    """
    if chat_history is None:
        chat_history = []

    logging.info(f"Inizio elaborazione domanda: {question} per database: {db_name}")
    
    try:
        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
        db_path = os.path.join(BASE_DB_PATH, f"faiss_index_{db_name}")  # Percorso corretto
        
        logging.info(f"Verifico esistenza database in: {db_path}")
        if not os.path.exists(db_path):
            logging.warning(f"Database {db_name} non trovato in {db_path}")
            return [
                {"role": "user", "content": question},
                {"role": "assistant", "content": f"Database non trovato in {db_path}"}
            ]
        
        # Carica l'indice FAISS
        vectorstore = FAISS.load_local(db_path, embeddings, allow_dangerous_deserialization=True)

        # Cerca i documenti (chunk) più simili
        relevant_docs = vectorstore.similarity_search(question, k=3)

        # Logga i chunk recuperati
        for idx, doc in enumerate(relevant_docs):
            logging.info(f"--- Chunk {idx+1} ---")
            logging.info(doc.page_content)
            logging.info("---------------------")

        # Prepara il contesto dai documenti
        context = "\n".join([doc.page_content for doc in relevant_docs])
        
        client = OpenAI(api_key=OPENAI_API_KEY)
        
        messages = [
            {"role": "system", "content": SYSTEM_PROMPTS[prompt_type].format(context=context)},
            {"role": "user", "content": question}
        ]
        
        # Esegui la chiamata a OpenAI
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            temperature=0.5,
            max_tokens=3048
        )
        
        answer = response.choices[0].message.content
        
        return [
            {"role": "user", "content": question},
            {"role": "assistant", "content": answer}
        ]

    except Exception as e:
        logging.error(f"Errore durante la generazione della risposta: {e}")
        return [
            {"role": "user", "content": question},
            {"role": "assistant", "content": f"Si è verificato un errore: {str(e)}"}
        ]



if __name__ == "__main__":
    
    pass