import streamlit as st

import logging
from langchain.chat_models import ChatOpenAI

# Import the function for detecting the "est une étape" pattern
from pattern_ce_qui_explique import explication, explication_prompt_template
from pattern_epoque import epoque, epoque_prompt_template
from pattern_est_une_etape import une_etape, est_une_etape_prompt_template, est_une_etape_prompt_template_v3, est_une_etape_prompt_template_v3_1
from pattern_adverbe_ment import adverbement, adverbement_prompt_template,adverbement_prompt_template_v3,adverbement_prompt_template_v3_1
from pattern_connecteur_cependant import connecteur, connecteur_prompt_template
from pattern_decision import decision, decision_prompt_template
from pattern_look import look, look_prompt_template
from pattern_il_existe import il_existe, il_existe_prompt_template
from pattern_il_faut import il_faut, il_faut_prompt_template
from pattern_vous_pouvez import vous_pouvez, vous_pouvez_prompt_template
from pattern_imaginez import imaginez, imaginez_prompt_template
from pattern_en_plus import en_plus_prompt_template, detect_en_plus
from pattern_outre import detect_outre, outre_prompt_template
from pattern_il_suffit_de import detect_il_suffit_de, il_suffit_de_prompt_template
from pattern_important_crucial import importance_prompt_template, importance_detection
from pattern_permettre import permettre_detection, permettre_prompt_template
from pattern_voici_decouvrez import detect_voici_decouvrez, voici_decouvrez_prompt_template
from erreurs_de_langue import detect_errors, academie_prompt_template
from erreur_de_style import detect_erreur_de_style, erreur_de_style_prompt_template

# Interface Streamlit
st.title("Analyse du texte")

# Liste des templates de prompt
List_prompt = {
    "<V2 Détection du pattern 'est une étape' >": est_une_etape_prompt_template(),
    "<V3 Détection du pattern 'est une étape' >": est_une_etape_prompt_template_v3(),
    "<V3.1 Détection du pattern 'est une étape' >": est_une_etape_prompt_template_v3_1(),
    "<V2 Détection du pattern 'epoque de, à l'ère de' >": epoque_prompt_template(),
    "<V2 Détection du pattern 'ce qui explique' >": explication_prompt_template(),
    "<V2 Détection des adverbes en -ment >": adverbement_prompt_template(),
    "<V3 Détection des adverbes en -ment >": adverbement_prompt_template_v3(),
    "<V3.1 Détection des adverbes en -ment >": adverbement_prompt_template_v3_1(),

    "<V2 Détection des connecteurs 'cependant' >": connecteur_prompt_template(),
    "<V2 Détection des decision 'éclairée...' >": decision_prompt_template(),
    "<V2 Détection du pattern 'look' >": look_prompt_template(),
    "<V2 Détection du pattern 'il existe' >": il_existe_prompt_template(),
    "<V2 Détection du pattern 'il faut' >": il_faut_prompt_template(),
    "<V2 Détection du pattern 'vous pouvez' >": vous_pouvez_prompt_template(),
    "<V2 Détection du pattern 'imaginez' >": imaginez_prompt_template(),
    "< Détection du pattern 'en plus' >": en_plus_prompt_template(),
    "< Détection du pattern 'outre' >": outre_prompt_template(),
    "< Détection du pattern 'il suffit de' >": il_suffit_de_prompt_template(),
    "< Détection du pattern 'important crucial' >": importance_prompt_template(),
    "<V2 Détection du pattern 'permettre' >": permettre_prompt_template(),
    "< Détection du pattern 'voici découvrez' >": voici_decouvrez_prompt_template(),
    "<V2 Détection des erreurs de 'langue courante' >" : academie_prompt_template(),
    "<V2 Détection des erreurs de style >": erreur_de_style_prompt_template()
}

# Menu déroulant pour sélectionner l'analyse
option = st.selectbox(
    "Choisissez l'analyse à effectuer :",
    List_prompt.keys()
)

# Afficher le prompt correspondant à l'option sélectionnée
selected_prompt = List_prompt.get(option, "")
st.subheader(f"Prompt : {option}")
st.text_area("Voici le prompt utilisé pour cette analyse :", value=selected_prompt, height=300, disabled=True)

# Champ de saisie du texte
input_text = st.text_area("Entrez votre texte ici :", height=200)

# Bouton d'analyse
if st.button("Lancer l'analyse"):
    if input_text:
        if option == "<V2 Détection du pattern 'est une étape' >":
            try:
                # Analyser le texte pour les fautes de style
                result = une_etape(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'est une étape'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V3 Détection du pattern 'est une étape' >":
            try:
                # Analyser le texte pour les fautes de style
                result = une_etape(input_text, version=2)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'est une étape'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V3.1 Détection du pattern 'est une étape' >":
            try:
                # Analyser le texte pour les fautes de style
                result = une_etape(input_text, version=3)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'est une étape'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")

        elif option == "<V2 Détection du pattern 'epoque de, à l'ère de' >":
            try:
                # Analyser le texte pour les fautes de style
                result = epoque(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'epoque de, à l'ère de'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection du pattern 'ce qui explique' >":
            try:
                # Analyser le texte pour les fautes de style
                result = explication(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'ce qui explique'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection des adverbes en -ment >":
            try:
                # Analyser le texte pour les fautes de style
                result = adverbement(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse des adverbes en -ment")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V3 Détection des adverbes en -ment >":
            try:
                # Analyser le texte pour les fautes de style
                result = adverbement(input_text, version=2)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse des adverbes en -ment")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V3.1 Détection des adverbes en -ment >":
            try:
                # Analyser le texte pour les fautes de style
                result = adverbement(input_text, version=3)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse des adverbes en -ment")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        
        elif option == "<V2 Détection des connecteurs 'cependant' >":
            try:
                # Analyser le texte pour les fautes de style
                result = connecteur(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse des connecteurs 'cependant'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection des decision 'éclairée...' >":
            try:
                # Analyser le texte pour les fautes de style
                result = decision(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse des decision 'éclairée...'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection du pattern 'look' >":
            try:
                # Analyser le texte pour les fautes de style
                result = look(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'look'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection du pattern 'il existe' >":
            try:
                # Analyser le texte pour les fautes de style
                result = il_existe(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'il existe'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection du pattern 'il faut' >":
            try:
                # Analyser le texte pour les fautes de style
                result = il_faut(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'il faut'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection du pattern 'vous pouvez' >":
            try:
                # Analyser le texte pour les fautes de style
                result = vous_pouvez(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'vous pouvez'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection du pattern 'imaginez' >":
            try:
                # Analyser le texte pour les fautes de style
                result = imaginez(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'imaginez'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "< Détection du pattern 'en plus' >":
            try:
                # Analyser le texte pour les fautes de style
                result = detect_en_plus(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'en plus'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "< Détection du pattern 'outre' >":
            try:
                # Analyser le texte pour les fautes de style
                result = detect_outre(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'outre'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "< Détection du pattern 'il suffit de' >":
            try:
                # Analyser le texte pour les fautes de style
                result = detect_il_suffit_de(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'il suffit de'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")

        elif option == "< Détection du pattern 'important crucial' >":
            try:
                # Analyser le texte pour les fautes de style
                result = importance_detection(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'important crucial'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "< Détection du pattern 'permettre' >":
            try:
                # Analyser le texte pour les fautes de style
                result = permettre_detection(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'permettre'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "< Détection du pattern 'voici découvrez' >":
            try:
                # Analyser le texte pour les fautes de style
                result = detect_voici_decouvrez(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse du pattern 'voici découvrez'")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                # st.subheader("Prompt final envoyé au modèle")
                # st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection des erreurs de 'langue courante' >" :
            try:
                # Analyser le texte pour les fautes de style
                result = detect_errors(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse des erreurs de style")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                st.subheader("Prompt final envoyé au modèle")
                st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
        
        elif option == "<V2 Détection des erreurs de style >":
            try:
                # Analyser le texte pour les fautes de style
                result = detect_erreur_de_style(input_text)

                # Afficher les résultats en JSON formaté
                st.subheader("Résultats de l'analyse des erreurs de style")
                st.json(result['result'], expanded=True)

                # Afficher le prompt final
                st.subheader("Prompt final envoyé au modèle")
                st.write(result['prompt'])

            except Exception as e:
                logging.error(f"Error during analysis: {e}")
                st.error(f"Une erreur s'est produite lors de l'analyse : {str(e)}")
    else:
        st.error("Veuillez entrer du texte pour lancer l'analyse.")