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

# Configura la tua chiave API in modo sicuro
api_key = os.getenv("OPENAI_API_KEY")  # Imposta la chiave come variabile d'ambiente

if not api_key:
    raise ValueError("Chiave API OpenAI non trovata. Assicurati di aver impostato OPENAI_API_KEY.")

# Crea il client utilizzando la chiave API
client = openai.Client(api_key=api_key)

# Percorsi per il primo file ZIP
zip_path_m = "faiss_manual_index.zip"  # File ZIP per l'indice manuale
faiss_manual_index = "faiss_manual_index"  # Sottocartella per estrazione manuale

# Controlla se la directory esiste già
if not os.path.exists(faiss_manual_index):
    os.makedirs(faiss_manual_index)  # Crea la directory

# Percorsi per il secondo file ZIP
zip_path_p = "faiss_problems_index.zip"  # File ZIP per l'indice problemi
faiss_problems_index = "faiss_problems_index"  # Sottocartella per estrazione problemi

# Controlla se la directory esiste già
if not os.path.exists(faiss_problems_index):
    os.makedirs(faiss_problems_index)  # Crea la directory

# Estrai il primo file ZIP se non esiste già
if os.path.exists(zip_path_m):  # Controlla che il file zip esista
    with zipfile.ZipFile(zip_path_m, 'r') as zip_ref:
        zip_ref.extractall(faiss_manual_index)
    print(f"Files estratti nella directory: {faiss_manual_index}")
else:
    print(f"File {zip_path_m} non trovato. Assicurati di caricarlo nello Space.")

# Estrai il secondo file ZIP se non esiste già
if os.path.exists(zip_path_p):  # Controlla che il file zip esista
    with zipfile.ZipFile(zip_path_p, 'r') as zip_ref:
        zip_ref.extractall(faiss_problems_index)
    print(f"Files estratti nella directory: {faiss_problems_index}")
else:
    print(f"File {zip_path_p} non trovato. Assicurati di caricarlo nello Space.")

# Carica il modello di embedding
embedding_model = HuggingFaceEmbeddings(model_name="sentence-transformers/LaBSE")

# Carica i vectorstore FAISS salvati
manual_vectorstore = FAISS.load_local(faiss_manual_index, embedding_model, allow_dangerous_deserialization=True)
problems_vectorstore = FAISS.load_local(faiss_problems_index, embedding_model, allow_dangerous_deserialization=True)

# Funzione per cercare nei dati FAISS e interrogare GPT
def search_and_answer(query):
    # Cerca nei manuali
    manual_results = manual_vectorstore.similarity_search(query, k=2)
    manual_output = "\n\n".join([doc.page_content for doc in manual_results])

    # Cerca nei problemi
    problems_results = problems_vectorstore.similarity_search(query, k=2)
    problems_output = "\n\n".join([doc.page_content for doc in problems_results])

    # Costruisce una domanda combinata
    combined_text = f"Manual Results: {manual_output}\n\nProblems Results: {problems_output}"
    response = rispondi_a_domanda(query, combined_text)
    
    return manual_output, problems_output, response

# Funzione per interrogare GPT
def rispondi_a_domanda(domanda, testo, max_token_risposta=350):
    print("verifica tutto",domanda,testo)
    try:
        # Chiamata API di OpenAI
        risposta = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": (
                    "Sei un assistente tecnico. Devi controllare la congruenza tra una domanda e un testo fornito, "
                    "e dare una risposta chiara, essenziale e pratica per aiutare un operatore a svolgere il compito. "
                    "Se il testo non contiene informazioni sufficienti per rispondere, dillo esplicitamente."
                )},
                {"role": "user", "content": (
                    f"Domanda: {domanda}\n"
                    f"Testo: {testo}\n"
                    "Rispondi in modo chiaro e operativo per un tecnico che deve svolgere la mansione."
                )}
            ],
            max_tokens=max_token_risposta,
            temperature=0.5,
        )

        # Estrai la risposta
        risposta_finale = risposta['choices'][0]['message']['content']
        return risposta_finale

    except Exception as e:
        print(f"Si è verificato un errore: {e}")
        return "Errore nell'elaborazione della risposta."

# Interfaccia Gradio
examples = [
    ["How to change the knife?"],
    ["What are the safety precautions for using the machine?"],
    ["How can I get help with the machine?"]
]

iface = gr.Interface(
    fn=search_and_answer,
    inputs=gr.Textbox(lines=2, placeholder="Enter your question here..."),
    outputs=[
        gr.Textbox(label="Manual Results"),
        gr.Textbox(label="Issues Results"),
        gr.Textbox(label="GPT-Generated Answer")
    ],
    examples=examples,
    title="Manual Querying System with GPT",
    description="Enter a question to get relevant information extracted from the manual and related issues, followed by a GPT-generated answer."
)

# Avvia l'app
iface.launch()