import sys
import io
import pandas as pd
from langchain_experimental.agents.agent_toolkits import create_csv_agent
from langchain_anthropic import ChatAnthropic
import gradio as gr
import os
from dotenv import load_dotenv

load_dotenv()

print(os.getenv("ANTHROPIC_API_KEY"))
# Configuration du modèle Anthropic
llm = ChatAnthropic(
    model="claude-3-7-sonnet-20250219",#claude-3-5-sonnet-20241022",
    temperature=0.1,
    api_key=os.getenv("ANTHROPIC_API_KEY")
)

# Liste des fichiers CSV disponibles
items = [
    "Contacts Prescripteurs-Ensemble des données.csv",
    "Lieux-Ensemble des données.csv",
    "Thèmes de séjour-Ensemble des données.csv",
    "Participants-Ensemble des données.csv",
    "Séjours-Séjours 2025 - Réunion équipe.csv"
]

# Fonction pour interroger les données CSV
def query_data(query, csv_file_path):

    # Rediriger la sortie standard vers un buffer
    old_stdout = sys.stdout
    new_stdout = io.StringIO()
    sys.stdout = new_stdout

    # Créer l'agent et invoquer la requête
    agent = create_csv_agent(
        llm,
        csv_file_path,
        verbose=True,
        return_intermediate_steps=True,
        max_iterations=8,
        allow_dangerous_code=True,
        handle_parsing_errors=True,
        include_df_in_prompt=False,
        # number_of_head_rows=1
    )
    try:
        response = agent.invoke(f"df.columns : \n{pd.read_csv(csv_file_path).columns}\n\n"+query)
        # Récupérer la sortie de la console
        console_output = new_stdout.getvalue()

        # Restaurer la sortie standard
        sys.stdout = old_stdout
        print(response)
        # Retourner la réponse et la sortie de la console
        return {
            "output": response["output"],
            "console_output":""
            # "console_output": response['intermediate_steps']
        }
    except Exception as e:
        console_output = new_stdout.getvalue()

        # Restaurer la sortie standard
        sys.stdout = old_stdout
        # Retourner la réponse et la sortie de la console
        return {
            "output": f"**Error :** {e}",
            "console_output": console_output+"\n"
        }
    


# Fonction de chat
def chat(question, csv_file_path, chat_history):
    csv_file_path +=".csv"
    # Appeler la fonction query_data
    result = query_data(question, csv_file_path)
    
    # Ajouter la question, la réponse finale et la sortie de la console à l'historique du chat
    chat_history.append((question, f"{result['console_output']}{result['output']}"))
    
    # Retourner l'historique mis à jour
    return chat_history

# Création de l'interface Gradio
with gr.Blocks() as demo:
    gr.Markdown("""# Your airtable assistant
Les conversations ne sont pas encore disponibles.""")
    
    with gr.Row():
        chatbot = gr.Chatbot(label="Chat")  # Composant Chatbot pour afficher les messages
    
    with gr.Row():  # Une ligne pour organiser les composants côte à côte
        with gr.Column():  # Colonne pour la question
            question = gr.Textbox(label="Posez votre question")
            submit_btn = gr.Button("Envoyer")
        with gr.Column():  # Colonne pour le dropdown
            dropdown = gr.Dropdown(choices=[elt[:-4] for elt in items], label="Sélectionnez une table")
    
    # Initialiser l'historique du chat
    chat_history = gr.State([])  # Utilisé pour stocker l'historique des messages
    
    # Lier les composants à la fonction de chat
    submit_btn.click(
        chat,  # Fonction à appeler
        inputs=[question, dropdown, chat_history],  # Entrées
        outputs=chatbot  # Sortie
    )

# Lancer l'interface
demo.launch(inbrowser=True)