from langchain.prompts import PromptTemplate
from langchain.output_parsers import PydanticOutputParser
from langchain.chat_models import ChatOpenAI
from pydantic import BaseModel, Field
from typing import List, Tuple
import json

# Modèle de sortie pour la détection de l'utilisation incorrecte de "Outre"
class OutreDetection(BaseModel):
    pattern: str = Field(..., description="Mot ou expression détectée, ici 'Outre'.")
    indices: List[Tuple[int, int]] = Field(..., description="Indices de début et de fin pour chaque occurrence dans le texte.")
    sentence: str = Field(..., description="Phrase complète où 'Outre' est utilisé.")
    explanation: str = Field(..., description="Explication de pourquoi l'utilisation de 'Outre' est incorrecte.")
    alternative_suggestions: List[str] = Field(..., description="Suggestions alternatives pour reformuler la phrase.")

    def to_dict(self):
        return {
            "pattern": self.pattern,
            "indices": self.indices,
            "sentence": self.sentence,
            "explanation": self.explanation,
            "alternative_suggestions": self.alternative_suggestions
        }

class Summary(BaseModel):
    total_patterns_detected: int = Field(..., description="Nombre total de patterns détectés.")
    alternative_suggestions_provided: int = Field(..., description="Nombre total de suggestions fournies.")
    occurrences: int = Field(..., description="Nombre total d'occurrences trouvées dans le texte.")

    def to_dict(self):
        return {
            "total_patterns_detected": self.total_patterns_detected,
            "alternative_suggestions_provided": self.alternative_suggestions_provided,
            "occurrences": self.occurrences
        }

class DetectionResult(BaseModel):
    patterns: List[OutreDetection] = Field(..., description="Liste des occurrences incorrectes de 'Outre'.")
    summary: Summary = Field(..., description="Résumé de la détection.")

    def to_dict(self):
        return {
            "patterns": [pattern.to_dict() for pattern in self.patterns],
            "summary": self.summary.to_dict()
        }

# Création du template pour la détection de l'utilisation incorrecte de "Outre"
def outre_prompt_template():
    return """
Veuillez analyser le texte suivant pour détecter les phrases où "Outre" est utilisé en début de phrase, sans être suivi d'un complément approprié.

Pour chaque phrase trouvée :

   - Citez la phrase originale contenant "Outre" en début de phrase.
   - Expliquez pourquoi l'utilisation de "Outre" est incorrecte et précisez qu'il s'agit d'une préposition qui doit être suivie d'un complément.
   - Proposez une correction en remplaçant "Outre" par "En outre" ou en réécrivant la phrase de manière correcte.
   - Assurez-vous que la phrase reformulée soit naturelle, fluide et correcte.

Voici l'explication à afficher : "Outre" est une préposition en français qui signifie "en plus de" ou "en dehors de", et doit être suivie d'un complément. Par exemple :

    - Correct : "Outre ses compétences en gestion, il est également un excellent communicateur."
    - Incorrect : "Outre, il est également un excellent communicateur."

Par contre, "En outre" est une locution adverbiale qui signifie "de plus" ou "en plus", et elle est correctement utilisée pour introduire une nouvelle idée ou information, souvent au début d'une phrase. Exemple :

    - Correct : "En outre, il a une grande expérience dans ce domaine."

En résumé :
   - "Outre" est une préposition et doit être suivi d'un complément.
   - "En outre" est une locution adverbiale et peut être utilisée seule au début d'une phrase pour introduire une nouvelle idée.

Analysez le texte ci-dessous et détectez toutes les occurrences de "cela signifie que".

Pour chaque phrase :

   - Citez la phrase originale.
   - Supprimez "cela signifie que" et proposez une reformulation concise et élégante qui maintient le sens de la phrase.
   - Assurez-vous que la phrase reformulée soit naturelle, fluide et correcte.

Le format de sortie doit être un JSON structuré avec les éléments suivants pour chaque pattern détecté :

   - "pattern": "mot ou expression détectée",
   - "indices": [[index de début, index de fin pour chaque occurrence]],
   - "sentence": "phrase où l'expression est utilisée",
   - "explanation": "explication de pourquoi l'expression est incorrecte",
   - "alternative_suggestions": ["suggestion 1", "suggestion 2"]

Si aucun pattern n'est trouvé, retournez un JSON avec :
   - "pattern0": "",
   - "occurrences": 0,

À la fin, ajoutez un résumé avec :
   - "total_patterns_detected": nombre total de patterns détectés,
   - "alternative_suggestions_provided": nombre de suggestions données,
   - "occurrences": nombre d'occurrences.

Le texte à analyser est :
```{text}```

{format_instruction}
"""

def detect_outre(text):
    # Création du modèle de sortie avec Pydantic
    output_parser = PydanticOutputParser(pydantic_object=DetectionResult)

    # Génération du prompt à partir du modèle
    gen_prompt_template = PromptTemplate(
        input_variables=["text"],
        template=outre_prompt_template(),
        partial_variables={'format_instruction': output_parser.get_format_instructions()}
    )

    # Création du modèle de langage (avec LLM)
    llm = ChatOpenAI(model='gpt-4o', temperature=0.5, api_key="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")

    # Chaîne de traitement du prompt avec le modèle et le parseur
    llm_chain = gen_prompt_template | llm | output_parser

    # Appel du modèle avec le texte fourni
    result_dict = llm_chain.invoke({"text": text}).to_dict()

    # Conversion du résultat en JSON
    json_result = json.dumps(result_dict, indent=8, ensure_ascii=False)

    # Génération du prompt final
    final_prompt = gen_prompt_template.format(text=text)

    # Retour des résultats
    return {
        "result": json_result,
        "prompt": final_prompt
    }