import gradio as gr
import numpy as np
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from transformers import MarianMTModel, MarianTokenizer
from openai import OpenAI
import faiss
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.")


client = OpenAI(api_key=api_key)
# Configura MarianMT per la traduzione multilingua
model_name = "Helsinki-NLP/opus-mt-it-en"
translator_tokenizer = MarianTokenizer.from_pretrained(model_name)
translator_model = MarianMTModel.from_pretrained(model_name)

# Percorsi dei file
faiss_index_path = "manual_embeddings.index"  # Percorso del file FAISS
chunk_file_path = "manual_chunks.txt"         # Percorso del file con i chunk

# Carica l'indice FAISS
index = faiss.read_index(faiss_index_path)

# Carica i chunk dal file
with open(chunk_file_path, "r", encoding="utf-8") as f:
    chunks = f.read().split("\n\n")  # Ogni chunk è separato da due newline

# Funzione per tradurre testo
def translate_text(text, source_lang="it", target_lang="en"):
    
    if source_lang == target_lang:
        return text  # Nessuna traduzione necessaria

    model_name = f"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}"
    tokenizer = MarianTokenizer.from_pretrained(model_name)
    model = MarianMTModel.from_pretrained(model_name)
    inputs = tokenizer(text, return_tensors="pt", padding=True)
    translated = model.generate(**inputs)
    return tokenizer.decode(translated[0], skip_special_tokens=True)

# Funzione per generare l'embedding della query usando OpenAI
def get_query_embedding(query, model="text-embedding-ada-002"):
    response = client.embeddings.create(model=model, input=[query])
    embedding = response.data[0].embedding
    return np.array(embedding)  # Restituisce l'embedding come array NumPy


# Funzione per cercare nel database FAISS
def search_in_faiss(query_embedding, k=3):
    query_embedding = np.expand_dims(query_embedding, axis=0)  # Assicura una matrice 2D
    distances, indices = index.search(query_embedding, k)
    return distances, indices

# Funzione per recuperare i chunk associati agli indici di FAISS
def get_chunks_from_indices(indices):
    retrieved_chunks = []
    for i in indices[0]:
        if 0 <= i < len(chunks):
            retrieved_chunks.append(chunks[i])
        else:
            retrieved_chunks.append(f"[Chunk non trovato per indice {i}]")
    return retrieved_chunks

# Funzione per rispondere alla domanda usando GPT-3
def generate_response(query, context, max_tokens=550):
    try:
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": (
                    "Sei un tecnico specializzato in macchine tessili da taglio. Rispondi in italiano alla domanda in modo chiaro, "
                    "usando un tono professionale ma accessibile. Se il testo non contiene informazioni sufficienti per rispondere, dillo in modo esplicito."
                )},
                {"role": "user", "content": (
                    f"Domanda: {query}\n"
                    f"Testo: {context}\n"
                    "Rispondi in modo chiaro e operativo per un tecnico che deve svolgere la mansione."
                )}
            ],
            max_tokens=max_tokens,
            temperature=0.5,
        )
        return response.choices[0].message.content
    except Exception as e:
        print(f"Errore durante la generazione della risposta: {e}")
        return "Errore nell'elaborazione della risposta."

# Funzione principale per ricerca e risposta
def search_and_answer(query, source_lang="it", target_lang="en"):
    # Traduci la query in inglese
    translated_query = translate_text(query, source_lang, target_lang)

    # Ottieni l'embedding della query
    query_embedding = get_query_embedding(translated_query)

    # Esegui la ricerca in FAISS
    distances, indices = search_in_faiss(query_embedding)

    # Recupera i chunk associati agli indici
    retrieved_chunks = get_chunks_from_indices(indices)
    context = "\n".join(retrieved_chunks)

    # Ottieni la risposta da GPT-3
    response = generate_response(query, context)

    # Traduci la risposta nella lingua originale
    #translated_response = translate_text(response, target_lang, source_lang)

    return context, response  #translated_response

# Interfaccia Gradio
examples = [
    ["Come cambio la lama della macchina?"],
    ["Quali sono le precauzioni di sicurezza per usare la macchina?"],
    ["Chi contattare in caso di problemi?"]
]

iface = gr.Interface(
    fn=search_and_answer,
    inputs=gr.Textbox(lines=2, placeholder="Inserisci la tua domanda qui..."),
    outputs=[
        gr.Textbox(label="Risultati della Ricerca"),
        gr.Textbox(label="Risposta Generata")
    ],
    examples=examples,
    title="Sistema RAG con Traduzione Multilingua",
    description=(
        "Inserisci una domanda in qualsiasi lingua supportata. Il sistema tradurrà la query, "
        "eseguirà la ricerca e genererà una risposta nella lingua originale."
    )
)

# Avvia l'app
iface.launch()