type3_preprocessing.py

import spacy
import openai
import re
from typing import Dict, List, Tuple
import json
from dataclasses import dataclass
from datetime import datetime
from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
import os
from dotenv import load_dotenv
from openai import AzureOpenAI
from medkit.core.text import TextDocument
from medkit.text.ner.hf_entity_matcher import HFEntityMatcher

NER_MODEL = os.getenv("NER_MODEL", "medkit/DrBERT-CASM2")

# Charger les variables d'environnement depuis .env
load_dotenv()

# Récupération des paramètres
AZURE_OPENAI_KEY = os.getenv("AZURE_OPENAI_KEY")
AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
AZURE_OPENAI_DEPLOYMENT = os.getenv("AZURE_OPENAI_DEPLOYMENT")
AZURE_OPENAI_API_VERSION = os.getenv("AZURE_OPENAI_API_VERSION", "2024-05-01-preview")

# Validation des variables d'environnement
def validate_azure_config():
    """Valide que toutes les variables Azure sont configurées"""
    missing_vars = []
    if not AZURE_OPENAI_KEY:
        missing_vars.append("AZURE_OPENAI_KEY")
    if not AZURE_OPENAI_ENDPOINT:
        missing_vars.append("AZURE_OPENAI_ENDPOINT")
    if not AZURE_OPENAI_DEPLOYMENT:
        missing_vars.append("AZURE_OPENAI_DEPLOYMENT")
    
    if missing_vars:
        print(f"❌ Variables d'environnement manquantes: {', '.join(missing_vars)}")
        print("📝 Veuillez créer un fichier .env avec:")
        for var in missing_vars:
            print(f"   {var}=votre_valeur")
        return False
    return True

# Client Azure OpenAI avec validation
azure_client = None
if validate_azure_config():
    try:
        azure_client = AzureOpenAI(
            api_key=AZURE_OPENAI_KEY,
            api_version=AZURE_OPENAI_API_VERSION,
            azure_endpoint=AZURE_OPENAI_ENDPOINT,
        )
        print("✅ Client Azure OpenAI initialisé avec succès")
    except Exception as e:
        print(f"❌ Erreur lors de l'initialisation du client Azure OpenAI: {e}")
        azure_client = None

ner_matcher = HFEntityMatcher(model=NER_MODEL)

@dataclass
class CorrectionResult:
    original_text: str
    ner_corrected_text: str
    final_corrected_text: str
    medical_entities: List[Dict]
    confidence_score: float

class MedicalNERCorrector:
    """Correcteur orthographique basé sur un NER médical français"""
    
    def __init__(self):
        try:
            # Charger le modèle MedKit NER
            self.matcher = HFEntityMatcher(model=NER_MODEL)
            print(f"✅ Modèle NER '{NER_MODEL}' chargé avec succès")
        except Exception as e:
            print(f"❌ Erreur lors du chargement du modèle NER {NER_MODEL}: {e}")
            self.matcher = None
        
        # Dictionnaire complet pour convertir tous les nombres en lettres vers chiffres
        self.number_corrections = {
            # Nombres de base
            "zéro": "0", "un": "1", "deux": "2", "trois": "3", "quatre": "4", 
            "cinq": "5", "six": "6", "sept": "7", "huit": "8", "neuf": "9", 
            "dix": "10", "onze": "11", "douze": "12", "treize": "13", "quatorze": "14",
            "quinze": "15", "seize": "16", "dix-sept": "17", "dix-huit": "18", 
            "dix-neuf": "19", "vingt": "20", "trente": "30", "quarante": "40",
            "cinquante": "50", "soixante": "60", "soixante-dix": "70", 
            "quatre-vingts": "80", "quatre-vingt": "80", "quatre-vingt-dix": "90",
            "cent": "100", "mille": "1000",
            
            # Variantes courantes dans les transcriptions vocales
            "1": "1", "1er": "1", "première": "1", "premier": "1",
            "2ème": "2", "deuxième": "2", "second": "2", "seconde": "2",
            "3ème": "3", "troisième": "3", "4ème": "4", "quatrième": "4",
            "5ème": "5", "cinquième": "5", "6ème": "6", "sixième": "6",
            "7ème": "7", "septième": "7", "8ème": "8", "huitième": "8",
            "9ème": "9", "neuvième": "9", "10ème": "10", "dixième": "10",
        }
        
        # Dictionnaire de corrections pour transcriptions vocales - ORDRE IMPORTANT
        self.vocal_corrections = {
            # Corrections de ponctuation - doivent être traitées en premier
            "point à la ligne": ".\n",
            "retour à la ligne": "\n",
            "à la ligne": "\n",
            "nouvelle ligne": "\n",
            "saut de ligne": "\n",
            "point virgule": ";",
            "deux points": ":",
            "point d'interrogation": "?",
            "point d'exclamation": "!",
            "virgule": ",",
            "point": ".",  # Doit être traité en dernier pour éviter les conflits
            
            # Corrections des séquences IRM
            "T un": "T1", "T deux": "T2", "T trois": "T3",
            "t un": "T1", "t deux": "T2", "t trois": "T3",
            "séquence T un": "séquence T1", "séquence T deux": "séquence T2",
            
            # Corrections des niveaux vertébraux - cervicaux
            "C un": "C1", "C deux": "C2", "C trois": "C3", "C quatre": "C4",
            "C cinq": "C5", "C six": "C6", "C sept": "C7",
            "c un": "C1", "c deux": "C2", "c trois": "C3", "c quatre": "C4", 
            "c cinq": "C5", "c six": "C6", "c sept": "C7",
            
            # Niveaux thoraciques
            "T un": "T1", "T deux": "T2", "T trois": "T3", "T quatre": "T4",
            "T cinq": "T5", "T six": "T6", "T sept": "T7", "T huit": "T8",
            "T neuf": "T9", "T dix": "T10", "T onze": "T11", "T douze": "T12",
            
            # Niveaux lombaires
            "L un": "L1", "L deux": "L2", "L trois": "L3", "L quatre": "L4", "L cinq": "L5",
            "l un": "L1", "l deux": "L2", "l trois": "L3", "l quatre": "L4", "l cinq": "L5",
            
            # Niveaux sacrés
            "S un": "S1", "S deux": "S2", "S trois": "S3", "S quatre": "S4", "S cinq": "S5",
            "s un": "S1", "s deux": "S2", "s trois": "S3", "s quatre": "S4", "s cinq": "S5",
        }
        
        # Dictionnaire de corrections médicales spécialisées - orthographe
        self.medical_corrections = {
            # Anatomie
            "rachis": ["rachis", "rachi", "rachys", "rahis", "raxis"],
            "cervical": ["cervical", "cervicale", "cervicaux", "servical", "servicale"],
            "vertébraux": ["vertébraux", "vertebraux", "vertébrau", "vertébral", "vertebral"],
            "médullaire": ["médullaire", "medullaire", "medulaire", "médulaire"],
            "foraminal": ["foraminal", "foraminale", "foraminaux", "forraminal"],
            "postérolatéral": ["postérolatéral", "posterolatéral", "postero-latéral", "postero latéral"],
            "antérolatéral": ["antérolatéral", "anterolatéral", "antero-latéral", "antero latéral"],
            "longitudinal": ["longitudinal", "longitudinale", "longitudinaux"],
            
            # Pathologies
            "uncarthrose": ["uncarthrose", "uncoarthrose", "uncartrose", "unkarthrose"],
            "lordose": ["lordose", "lordoze", "lordosse", "lordosse"],
            "cyphose": ["cyphose", "siphose", "kyphose", "kiphose"],
            "scoliose": ["scoliose", "skoliose", "scholiose"],
            "discopathie": ["discopathie", "disccopathie", "discopatie"],
            "discal": ["discal", "discale", "diskal", "diskale", "disque"],
            "hernie": ["hernie", "herny", "herni"],
            "protrusion": ["protrusion", "protusion", "protruzion"],
            "sténose": ["sténose", "stenose", "sténoze"],
            "arthrose": ["arthrose", "artrose", "arthroze"],
            "ostéophyte": ["ostéophyte", "osteophyte", "ostéofite"],
            "ligamentaire": ["ligamentaire", "ligamentere", "ligamentair"],
            
            # Techniques et examens
            "sagittal": ["sagittal", "sagittale", "sagital", "sagittaux"],
            "coronal": ["coronal", "coronale", "coronaux"],
            "axial": ["axial", "axiale", "axiaux", "axial"],
            "transversal": ["transversal", "transversale", "transversaux"],
            "pondéré": ["pondéré", "pondéré", "pondere", "pondérée"],
            "séquence": ["séquence", "sequence", "sekence"],
            "contraste": ["contraste", "contraste", "kontraste"],
            "gadolinium": ["gadolinium", "gadoliniun", "gadoliniom"],
            
            # Mesures et directions
            "millimètre": ["millimètre", "millimetre", "mm"],
            "centimètre": ["centimètre", "centimetre", "cm"],
            "gauche": ["gauche", "gosh", "goshe", "goche"],
            "droite": ["droite", "droitte", "droithe", "droitr"],
            "antérieur": ["antérieur", "anterieur", "antérieure", "anterieure"],
            "postérieur": ["postérieur", "posterieur", "postérieure", "posterieure"],
            "supérieur": ["supérieur", "superieur", "supérieure", "superieure"],
            "inférieur": ["inférieur", "inferieur", "inférieure", "inferieure"],
            "médian": ["médian", "median", "mediane", "médiane"],
            "latéral": ["latéral", "lateral", "laterale", "latérale"],
            
            # Signaux et aspects
            "signal": ["signal", "signale", "signa", "signaux"],
            "hypersignal": ["hypersignal", "hyper signal", "hypersignale"],
            "hyposignal": ["hyposignal", "hypo signal", "hyposignale"],
            "isosignal": ["isosignal", "iso signal", "isosignale"],
            "hétérogène": ["hétérogène", "heterogene", "hétérogène"],
            "homogène": ["homogène", "homogene", "omogene"],
            
            # Autres termes fréquents
            "dimension": ["dimension", "dimention", "dimmension"],
            "normale": ["normale", "normal", "normalle"],
            "anomalie": ["anomalie", "annomalie", "anomaly"],
            "décelable": ["décelable", "decelabl", "décellabl"],
            "absence": ["absence", "abscence", "absance"],
            "présence": ["présence", "presence", "presance"],
            "contact": ["contact", "contacte", "kontak"],
            "compression": ["compression", "compresion", "kompression"],
        }
        
        # Expressions régulières pour les patterns médicaux
        self.medical_patterns = {
            "vertebral_level": r"[CTLS]\d+[\s-]*[CTLS]\d+",
            "measurement": r"\d+[\s]*[x×]\s*\d+\s*mm",
            "technique": r"T[1-3]",
        }

    def convert_numbers_to_digits(self, text: str) -> str:
        """Convertit TOUS les nombres en lettres vers des chiffres"""
        corrected_text = text
        
        # ÉTAPE 1: Gestion spéciale des mesures médicales communes
        medical_measures = {
            # Mesures d'utérus courantes
            "sept point huit": "7,8",
            "trois sept": "3,7", 
            "soixante": "60",
            
            # Mesures d'ovaires courantes  
            "vingt six": "26",
            
            "vingt cinq": "25",
            "dix neuf": "19",
            "vingt deux": "22",
            
            # Mesures Doppler
            "trois vingt quatre": "3,24",  # IP
            "quatre vingt onze": "0,91",   # IR (avec virgule décimale)
            
            # Autres mesures courantes
            "quinze": "15",
        }
        
        # Application des mesures médicales en premier
        for word_measure, digit_measure in medical_measures.items():
            pattern = r'\b' + re.escape(word_measure) + r'\b'
            corrected_text = re.sub(pattern, digit_measure, corrected_text, flags=re.IGNORECASE)
        
        # ÉTAPE 2: Traitement des nombres composés restants
        compound_without_dash = {
        "vingt un": "21", "vingt deux": "22", "vingt trois": "23", "vingt quatre": "24",
        "vingt cinq": "25", "vingt six": "26", "vingt sept": "27", "vingt huit": "28",
        "vingt neuf": "29", "trente un": "31", "trente deux": "32", "trente trois": "33",
        "trente quatre": "34", "trente cinq": "35", "trente six": "36", "trente sept": "37",
        "trente huit": "38", "trente neuf": "39", "quarante un": "41", "quarante deux": "42",
        "quarante trois": "43", "quarante quatre": "44", "quarante cinq": "45",
        "quarante six": "46", "quarante sept": "47", "quarante huit": "48", "quarante neuf": "49",
        "cinquante un": "51", "cinquante deux": "52", "cinquante trois": "53",
        "cinquante quatre": "54", "cinquante cinq": "55", "cinquante six": "56",
        "cinquante sept": "57", "cinquante huit": "58", "cinquante neuf": "59",
        "soixante un": "61", "soixante deux": "62", "soixante trois": "63",
        "soixante quatre": "64", "soixante cinq": "65", "soixante six": "66",
        "soixante sept": "67", "soixante huit": "68", "soixante neuf": "69",
        "soixante et onze": "71", "soixante douze": "72", "soixante treize": "73",
        "soixante quatorze": "74", "soixante quinze": "75", "soixante seize": "76",
        "soixante dix sept": "77", "soixante dix huit": "78", "soixante dix neuf": "79",
        "quatre vingt un": "81", "quatre vingt deux": "82", "quatre vingt trois": "83",
        "quatre vingt quatre": "84", "quatre vingt cinq": "85", "quatre vingt six": "86",
        "quatre vingt sept": "87", "quatre vingt huit": "88", "quatre vingt neuf": "89",
        "quatre vingt onze": "91", "quatre vingt douze": "92", "quatre vingt treize": "93",
        "quatre vingt quatorze": "94", "quatre vingt quinze": "95", "quatre vingt seize": "96",
        "quatre vingt dix sept": "97", "quatre vingt dix huit": "98", "quatre vingt dix neuf": "99",

        }
        
        for word, digit in compound_without_dash.items():
            # Protection : ne remplace PAS si suivi de "fois" ET d'un autre nombre
            pattern = r'\b' + re.escape(word) + r'\b(?!\s+fois\s+\w+)'
            corrected_text = re.sub(pattern, digit, corrected_text, flags=re.IGNORECASE)
        
        # ÉTAPE 3: Nombres simples (ordre modifié pour éviter les conflits)
        simple_numbers = {
            "zéro": "0", "un": "1", "deux": "2", "trois": "3", "quatre": "4", 
            "cinq": "5", "six": "6", "sept": "7", "huit": "8", "neuf": "9", 
            "dix": "10", "onze": "11", "douze": "12", "treize": "13", "quatorze": "14",
            "quinze": "15", "seize": "16", "dix-sept": "17", "dix-huit": "18", 
            "dix-neuf": "19", "vingt": "20", "trente": "30", "quarante": "40",
            "cinquante": "50", "soixante-dix": "70", 
            "quatre-vingts": "80", "quatre-vingt": "80", "quatre-vingt-dix": "90",
            "cent": "100", "mille": "1000",
        }
        
        # Conversion des nombres simples
        for word_number, digit in simple_numbers.items():
            pattern = r'\b' + re.escape(word_number) + r'\b'
            corrected_text = re.sub(pattern, digit, corrected_text, flags=re.IGNORECASE)
        
        return corrected_text

    def extract_medical_entities(self, text: str):
        """Extrait les entités médicales avec MedKit HFEntityMatcher"""
        if not self.matcher:
            return []
        doc = TextDocument(text)
        entities = self.matcher.run([doc.raw_segment])
        # Transformer en format simple
        formatted_entities = []
        for ent in entities:
            formatted_entities.append({
                "text": ent.text,
                "label": ent.label,
            })
        return formatted_entities
    
    def correct_vocal_transcription(self, text: str) -> str:
        """Corrige les transcriptions vocales avec un ordre de priorité strict"""
        corrected_text = text
        
        # ÉTAPE 1: Conversion des nombres AVANT tout le reste
        corrected_text = self.convert_numbers_to_digits(corrected_text)
        
        # ÉTAPE 2: Corrections des expressions vocales dans l'ordre de priorité
        # L'ordre est CRUCIAL pour éviter les conflits
        priority_corrections = [
            # Expressions de ponctuation complexes en premier
            ("point à la ligne", ".\n"),
            ("retour à la ligne", "\n"),
            ("à la ligne", "\n"),
            ("nouvelle ligne", "\n"),
            ("saut de ligne", "\n"),
            ("point virgule", ";"),
            ("deux points", ":"),
            ("point d'interrogation", "?"),
            ("point d'exclamation", "!"),
            
            # Niveaux vertébraux avec nombres
            ("C 1", "C1"), ("C 2", "C2"), ("C 3", "C3"), ("C 4", "C4"),
            ("C 5", "C5"), ("C 6", "C6"), ("C 7", "C7"),
            ("L 1", "L1"), ("L 2", "L2"), ("L 3", "L3"), ("L 4", "L4"), ("L 5", "L5"),
            ("T 1", "T1"), ("T 2", "T2"), ("T 3", "T3"), ("T 4", "T4"),
            ("T 5", "T5"), ("T 6", "T6"), ("T 7", "T7"), ("T 8", "T8"),
            ("T 9", "T9"), ("T 10", "T10"), ("T 11", "T11"), ("T 12", "T12"),
            
            # Séquences IRM
            ("séquence T 1", "séquence T1"), ("séquence T 2", "séquence T2"),
            
            # Virgule et point en dernier pour éviter les conflits
            ("virgule", ","),
        ]
        
        for vocal_term, replacement in priority_corrections:
            # Utilisation de word boundaries pour éviter les remplacements partiels
            pattern = r'\b' + re.escape(vocal_term) + r'\b'
            corrected_text = re.sub(pattern, replacement, corrected_text, flags=re.IGNORECASE)
        
        # ÉTAPE 3: Correction spéciale pour "point" - seulement si c'est vraiment une fin de phrase
        # Pattern pour détecter "point" suivi d'un espace et d'une majuscule OU en fin de texte
        corrected_text = re.sub(r'\bpoint(?!\s+(?:à|d\'|virgule))', '.', corrected_text, flags=re.IGNORECASE)
        
        return corrected_text

    def correct_medical_terms(self, text: str) -> str:
        """Corrige les termes médicaux basés sur le dictionnaire"""
        corrected_text = text
        
        for correct_term, variations in self.medical_corrections.items():
            for variation in variations:
                if variation != correct_term:  # Éviter de remplacer par lui-même
                    # Correction avec préservation de la casse du premier caractère
                    pattern = r'\b' + re.escape(variation) + r'\b'
                    
                    def replace_with_case(match):
                        matched_text = match.group(0)
                        if matched_text[0].isupper():
                            return correct_term.capitalize()
                        return correct_term
                    
                    corrected_text = re.sub(pattern, replace_with_case, corrected_text, flags=re.IGNORECASE)
        
        return corrected_text

    def normalize_medical_patterns(self, text: str) -> str:
        """Normalise les patterns médicaux avec gestion des mesures"""
        normalized_text = text

        # Gestion spéciale des mesures avec "fois" (dimensions)
        # Pattern: nombre fois nombre -> nombre x nombre
        normalized_text = re.sub(r'(\d+(?:[.,]\d+)?)\s+fois\s+(\d+(?:[.,]\d+)?)', r'\1 x \2', normalized_text, flags=re.IGNORECASE)

        # Normalisation des niveaux vertébraux (ex: C5 C6 -> C5-C6, C5c6 -> C5-C6)
        normalized_text = re.sub(r'([CTLS])(\d)\s*([CTLS])?(\d)', lambda m: f"{m.group(1)}{m.group(2)}-{m.group(1)}{m.group(4)}", normalized_text, flags=re.IGNORECASE)

        # Normalisation des mesures existantes (ex: 72x40mm -> 72 x 40 mm)
        normalized_text = re.sub(r'(\d+(?:[.,]\d+)?)\s*[x×]\s*(\d+(?:[.,]\d+)?)\s*mm', r'\1 x \2 mm', normalized_text)

        # Ajout automatique de l'unité mm pour les mesures sans unité (nombre x nombre -> nombre x nombre mm)
        normalized_text = re.sub(r'(\d+(?:[.,]\d+)?)\s*x\s*(\d+(?:[.,]\d+)?)(?!\s*(?:mm|cm))', r'\1 x \2 mm', normalized_text, flags=re.IGNORECASE)

        # Normalisation des millimètres écrits en toutes lettres
        normalized_text = re.sub(r'(\d+(?:[.,]\d+)?)\s*millimètres?', r'\1 mm', normalized_text, flags=re.IGNORECASE)

        # Gestion des mesures d'hystérométrie (format spécial)
        normalized_text = re.sub(r"d['’]?hystérométrie\s+(\d+(?:[.,]\d+)?)", r"d'hystérométrie : \1 mm", normalized_text, flags=re.IGNORECASE)

        # Gestion des mesures d'endomètre
        normalized_text = re.sub(r"d['’]?endomètre\s+(\d+(?:[.,]\d+)?)", r"d'endometre : \1 mm", normalized_text, flags=re.IGNORECASE)

        # Gestion du CFA (Compte Folliculaire Antral)
        normalized_text = re.sub(r'(\d+)\s+follicules', r'CFA \1 follicules', normalized_text, flags=re.IGNORECASE)

        return normalized_text

    def clean_spacing_and_formatting(self, text: str) -> str:
        """Nettoie les espaces et améliore le formatage avec ajouts spécifiques"""
        # Supprime les espaces multiples mais préserve les sauts de ligne
        text = re.sub(r'[ \t]+', ' ', text)
        
        # AJOUT: Corrections spécifiques pour les mesures
        # Corrige "7. 8" -> "7,8" (décimales)
        text = re.sub(r'(\d+)\.\s+(\d+)(?!\s*(?:mm|cm|fois|x))', r'\1,\2', text)
        
        # Corrige "20 6" -> "26" quand c'est clairement un nombre
        text = re.sub(r'\b20\s+6\b', '26', text)
        text = re.sub(r'\b20\s+5\b', '25', text) 
        text = re.sub(r'\b10\s+9\b', '19', text)
        text = re.sub(r'\b20\s+2\b', '22', text)
        text = re.sub(r'\b20\s+7\b', '27', text)  
        text = re.sub(r'\b3\s+20\s+4\b', '3,24', text)  
        text = re.sub(r'\b4\s+20\s+11\b', '0,91', text)  
        
        # Corrige la ponctuation (supprime l'espace avant les points, virgules)
        text = re.sub(r'\s+([.,:;!?])', r'\1', text)
        
        # Ajoute un espace après la ponctuation si nécessaire (sauf si suivi d'un saut de ligne)
        text = re.sub(r'([.,:;!?])([A-Za-z])', r'\1 \2', text)
        
        # AJOUT: Correction des apostrophes
        text = re.sub(r'\bl\s+([aeiouAEIOU])', r"l'\1", text)  # l ovaire -> l'ovaire
        text = re.sub(r'\bd\s+([aeiouAEIOU])', r"d'\1", text)  # d hystérométrie -> d'hystérométrie
        
        # Nettoie les sauts de ligne multiples (max 2 consécutifs)
        text = re.sub(r'\n\s*\n\s*\n+', '\n\n', text)
        
        # Supprime les espaces en début et fin de ligne
        lines = text.split('\n')
        lines = [line.strip() for line in lines]
        text = '\n'.join(lines)
        
        # Capitalise après les points suivis d'un espace
        text = re.sub(r'(\.\s+)([a-z])', lambda m: m.group(1) + m.group(2).upper(), text)
        
        # Capitalise le début du texte
        if text and text[0].islower():
            text = text[0].upper() + text[1:]
        
        return text.strip()
    def post_process_gynecology_report(self, text: str) -> str:
        """Post-traitement spécialisé pour les rapports gynécologiques"""
        processed_text = text
        
        # Structuration des mesures d'utérus
        processed_text = re.sub(
            r'utérus est (\w+)\s+(\d+,\d+)', 
            r'utérus est \1 de taille \2 cm', 
            processed_text, 
            flags=re.IGNORECASE
        )
        
        # Structuration des mesures d'ovaires
        processed_text = re.sub(
            r'ovaire (droit|gauche) (\d+ x \d+ mm)', 
            r'ovaire \1 mesure \2,', 
            processed_text, 
            flags=re.IGNORECASE
        )
        
        # Amélioration de la lisibilité du CFA
        processed_text = re.sub(
            r'CFA (\d+) follicules', 
            r'CFA : \1 follicules', 
            processed_text, 
            flags=re.IGNORECASE
        )
        
        # Formatage des indices Doppler
        processed_text = re.sub(
            r'doppler.*?(\d,\d+).*?(\d,\d+)', 
            r'Doppler : IP \1 - IR \2', 
            processed_text, 
            flags=re.IGNORECASE
        )
        
        return processed_text

class GPTMedicalFormatter:
    """Formateur de rapports médicaux utilisant GPT"""
    
    def __init__(self, model: str = AZURE_OPENAI_DEPLOYMENT):
        self.model = model
        
        self.system_prompt = """
Tu es un expert en transcription médicale française. Tu dois corriger et formater UNIQUEMENT les erreurs évidentes dans ce texte médical déjà pré-traité.

RÈGLES STRICTES À APPLIQUER :

1. **PONCTUATION** :
   - Supprime les doubles ponctuations : ",." → "."
   - Supprime ".." → "."
   - Corrige ",?" → "?"

2. **PARENTHÈSES** déjà converties mais nettoie si nécessaire

3. **ORTHOGRAPHE MÉDICALE** :
   - "supérieur" au lieu de "supérieure" pour les adjectifs masculins
   - "Discrète" → "Discret" pour les termes masculins
   - Autres termes médicaux mal orthographiés

4. **FORMATAGE** :
   - Assure-toi que chaque phrase se termine par un point
   - Capitalise après les points
   - Supprime les espaces inutiles

5. **INTERDICTIONS** :
   - NE change PAS le contenu médical
   - NE reformule PAS les phrases
   - NE change PAS l'ordre des informations
   - NE supprime PAS d'informations médicales

OBJECTIF : Rendre le texte médical propre et professionnel en gardant EXACTEMENT le même contenu.

Texte à corriger :
"""

    def format_medical_report(self, text: str) -> str:
        """Formate le rapport médical avec GPT"""
        if not azure_client:
            print("❌ Client Azure OpenAI non disponible - utilisation du texte NER seulement")
            return text
            
        try:
            print("🔄 Appel à l'API Azure OpenAI en cours...")
            response = azure_client.chat.completions.create(
                model=self.model,   
                messages=[
                    {"role": "system", "content": self.system_prompt},
                    {"role": "user", "content": f"Corrigez et formatez cette transcription médicale en préservant tous les sauts de ligne et le contenu médical:\n\n{text}"}
                ],
                #max_tokens=2000,
                #temperature=0.1
            )
            result = response.choices[0].message.content.strip()
            print("✅ Réponse reçue de l'API Azure OpenAI")
            return result
            
        except Exception as e:
            print(f"❌ Erreur lors de l'appel à l'API Azure OpenAI: {e}")
            print(f"   Type d'erreur: {type(e).__name__}")
            if hasattr(e, 'response'):
                print(f"   Code de statut: {e.response.status_code if hasattr(e.response, 'status_code') else 'N/A'}")
            print("🔄 Utilisation du texte corrigé par NER seulement")
            return text

class MedicalTranscriptionProcessor:
    """Processeur principal pour les transcriptions médicales"""
    
    def __init__(self, deployment: str = AZURE_OPENAI_DEPLOYMENT):
        self.ner_corrector = MedicalNERCorrector()
        self.gpt_formatter = GPTMedicalFormatter(deployment)
    
    def process_transcription(self, text: str) -> CorrectionResult:
        """Traite une transcription médicale complète - TRAITEMENT OBLIGATOIRE EN 2 ÉTAPES"""
        print("🏥 Démarrage du traitement de la transcription médicale...")
        print("⚠️  TRAITEMENT EN 2 ÉTAPES OBLIGATOIRES: NER + GPT")
        
        # =================== ÉTAPE 1: CORRECTIONS NER ===================
        print("\n🔧 ÉTAPE 1/2: CORRECTIONS NER (Nombres, Ponctuation, Orthographe)")
        print("-" * 60)
        
        # Sous-étape 1.1: Correction des transcriptions vocales (inclut la conversion des nombres)
        print("  🎤 Correction des transcriptions vocales et conversion des nombres...")
        vocal_corrected = self.ner_corrector.correct_vocal_transcription(text)
        
        # Sous-étape 1.2: Extraction des entités médicales
        print("  📋 Extraction des entités médicales...")
        medical_entities = self.ner_corrector.extract_medical_entities(vocal_corrected)
        print(f"     ✅ {len(medical_entities)} entités médicales détectées")
        
        # Sous-étape 1.3: Correction orthographique des termes médicaux
        print("  ✏️  Correction orthographique des termes médicaux...")
        ner_corrected = self.ner_corrector.correct_medical_terms(vocal_corrected)
        
        # Sous-étape 1.4: Normalisation des patterns médicaux
        print("  🔧 Normalisation des patterns médicaux...")
        ner_corrected = self.ner_corrector.normalize_medical_patterns(ner_corrected)
        
        # Sous-étape 1.5: Nettoyage du formatage
        print("  🧹 Nettoyage du formatage...")
        ner_corrected = self.ner_corrector.post_process_gynecology_report(ner_corrected)

        
        print("✅ ÉTAPE 1 TERMINÉE: Corrections NER appliquées")
        
        # =================== ÉTAPE 2: FORMATAGE GPT ===================
        print("\n🤖 ÉTAPE 2/2: FORMATAGE PROFESSIONNEL AVEC GPT")
        print("-" * 60)
        print("  📝 Structuration du rapport médical...")
        print("  🎯 Amélioration de la lisibilité...")
        print("  📋 Organisation en sections médicales...")
        
        final_corrected = self.gpt_formatter.format_medical_report(ner_corrected)
        
        if final_corrected != ner_corrected:
            print("✅ ÉTAPE 2 TERMINÉE: Formatage GPT appliqué avec succès")
        else:
            print("⚠️  ÉTAPE 2: GPT non disponible - utilisation du résultat NER")
        
        # Calcul du score de confiance
        confidence_score = self._calculate_confidence_score(text, final_corrected, medical_entities)
        
        print(f"\n🎯 TRAITEMENT COMPLET TERMINÉ - Score de confiance: {confidence_score:.2%}")
        
        return CorrectionResult(
            original_text=text,
            ner_corrected_text=ner_corrected,
            final_corrected_text=final_corrected,
            medical_entities=medical_entities,
            confidence_score=confidence_score
        )
    
    def process_without_gpt(self, text: str) -> str:
        print("⚠️  ATTENTION: Traitement partiel sans GPT (pour tests uniquement)")
        print("💡 Pour un résultat professionnel, utilisez process_transcription() avec une clé API")
        
        vocal_corrected = self.ner_corrector.correct_vocal_transcription(text)
        medical_corrected = self.ner_corrector.correct_medical_terms(vocal_corrected)
        normalized = self.ner_corrector.normalize_medical_patterns(medical_corrected)
        cleaned = self.ner_corrector.clean_spacing_and_formatting(normalized)
        return cleaned
    
    def _calculate_confidence_score(self, original: str, corrected: str, entities: List[Dict]) -> float:
        """Calcule un score de confiance pour la correction"""
        entity_score = min(len(entities) / 10, 1.0)
        similarity_score = len(set(original.split()) & set(corrected.split())) / len(set(original.split()))
        return (entity_score + similarity_score) / 2

def test_azure_connection():
    """Test de connexion à Azure OpenAI"""
    if not azure_client:
        print("❌ Client Azure OpenAI non initialisé")
        return False
        
    try:
        print("🔍 Test de connexion à Azure OpenAI...")
        response = azure_client.chat.completions.create(
            model=AZURE_OPENAI_DEPLOYMENT,
            messages=[{"role": "user", "content": "Test de connexion"}]
            #max_tokens=10
        )
        print("✅ Connexion Azure OpenAI réussie")
        return True
    except Exception as e:
        print(f"❌ Erreur de connexion Azure OpenAI: {e}")
        return False

def main():
    """Fonction principale de démonstration"""
    
    # Test de la configuration Azure
    print("=" * 80)
    print("🔧 VÉRIFICATION DE LA CONFIGURATION")
    print("=" * 80)
    
    print(f"📍 Endpoint Azure: {AZURE_OPENAI_ENDPOINT}")
    print(f"🤖 Deployment: {AZURE_OPENAI_DEPLOYMENT}")
    print(f"🔑 Clé API: {'✅ Configurée' if AZURE_OPENAI_KEY else '❌ Manquante'}")
    
    # Test de connexion
    if not test_azure_connection():
        print("\n⚠️  Azure OpenAI non disponible - le traitement continuera avec NER seulement")
    
    # Texte d'exemple avec problèmes identifiés
    exemple_transcription = """irm pelvienne indication clinique point technique acquisition sagittale axiale et coronale t deux saturation axiale diffusion axiale t un résultats présence d un utérus antéversé médio pelvien dont le grand axe mesure soixante douze mm sur quarante millimètre sur quarante mm point la zone jonctionnelle apparaît floue point elle est épaissie de façon diffuse asymétrique avec une atteinte de plus de cinquante pour cent de l épaisseur du myomètre et comporte des spots en hypersignal t deux l ensemble traduisant une adénomyose point à la ligne pas d épaississement cervical à noter la présence d un petit kyste liquidien de type naboth point à la ligne les deux ovaires sont repérés porteurs de formations folliculaires communes en hypersignal homogène t deux de petite taille point l ovaire droit mesure trente fois vingt cinq mm l ovaire gauche vingt cinq fois vingt trois mm point pas d épanchement dans le cul de sac de douglas point à la ligne absence de foyer d endométriose profonde point conclusion points à la ligne aspect d adénomyose diffuse symétrique virgule profonde point à la ligne pas d épaississement endométrial point absence d endométriome point absence d épanchement dans le cul de sac de douglas point"""
    
    # Initialisation du processeur
    processor = MedicalTranscriptionProcessor(AZURE_OPENAI_DEPLOYMENT)
    
    print("\n" + "="*80)
    print("🏥 TRAITEMENT COMPLET DE LA TRANSCRIPTION MÉDICALE")
    print("="*80)
    
    # Traitement complet avec GPT (recommandé)
    result = processor.process_transcription(exemple_transcription)
    
    # Affichage des résultats complets
    print("\n📄 TEXTE ORIGINAL:")
    print("-" * 50)
    print(result.original_text)
    
    print(f"\n🔍 ENTITÉS MÉDICALES DÉTECTÉES ({len(result.medical_entities)}):")
    print("-" * 50)
    for entity in result.medical_entities:
        print(f"  • {entity['text']} ({entity['label']})")
    
    print("\n🎤 APRÈS CORRECTION NER (sans GPT):")
    print("-" * 50)
    print(result.ner_corrected_text)
    
    print("\n🤖 RAPPORT FINAL FORMATÉ (avec GPT):")
    print("-" * 50)
    if result.final_corrected_text:
        print(result.final_corrected_text)
    else:
        print("❌ Aucun résultat GPT - vérifiez votre configuration Azure")
    
    print(f"\n📊 SCORE DE CONFIANCE: {result.confidence_score:.2%}")
    
    # Comparaison des résultats
    if result.final_corrected_text != result.ner_corrected_text:
        print("\n🔄 COMPARAISON NER vs GPT:")
        print("-" * 50)
        print("📈 Améliorations apportées par GPT:")
        ner_lines = result.ner_corrected_text.split('\n')
        gpt_lines = result.final_corrected_text.split('\n')
        
        for i, (ner_line, gpt_line) in enumerate(zip(ner_lines, gpt_lines)):
            if ner_line.strip() != gpt_line.strip():
                print(f"  Ligne {i+1}:")
                print(f"    NER: {ner_line}")
                print(f"    GPT: {gpt_line}")
    
    print("\n" + "="*80)
    print("✅ TRAITEMENT TERMINÉ")
    if azure_client:
        print("🎉 Les 2 étapes ont été appliquées avec succès")
    else:
        print("⚠️  Seule l'étape NER a pu être appliquée - configurez Azure OpenAI pour le formatage complet")
    print("="*80)

if __name__ == "__main__":
    print("✅ correcteur.py loaded main")
    main()