type3_extract_entities.py

import os
import re
import json
import logging
from typing import Dict, List, Optional, Tuple, Any
from dataclasses import dataclass, asdict
from openai import AzureOpenAI

# Configuration des logs
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class MedicalEntity:
    """Entité médicale extraite"""
    entity_type: str  # "UTERUS_POSITION", "MEASUREMENT", etc.
    value: str        # Valeur extraite
    unit: Optional[str] = None  # mm, cm, etc.
    confidence: float = 0.0     # Score de confiance
    context: str = ""           # Contexte d'extraction
    start_pos: int = -1         # Position dans le texte
    end_pos: int = -1

@dataclass
class ExtractedData:
    """Données médicales structurées extraites"""
    # Utérus
    uterus_position: Optional[str] = None
    uterus_size: Optional[str] = None
    hysterometry: Optional[str] = None
    
    # Endomètre
    endometrium_thickness: Optional[str] = None
    
    # Myomètre/Zone jonctionnelle
    myomas_present: Optional[bool] = None
    zone_jonctionnelle_status: Optional[str] = None  # normale/épaissie
    adenomyosis_type: Optional[str] = None  # diffuse/focale/absente
    
    # Ovaire droit
    right_ovary_dimensions: Optional[str] = None
    right_ovary_cfa: Optional[str] = None
    right_ovary_accessibility: Optional[str] = None
    
    # Ovaire gauche
    left_ovary_dimensions: Optional[str] = None
    left_ovary_cfa: Optional[str] = None
    left_ovary_accessibility: Optional[str] = None
    
    # Doppler
    doppler_ip: Optional[str] = None
    doppler_ir: Optional[str] = None
    
    # Métadonnées
    extraction_confidence: float = 0.0
    missing_fields: List[str] = None
    
    def __post_init__(self):
        if self.missing_fields is None:
            self.missing_fields = []

class MedicalNERAgent:
    """Agent NER médical utilisant GPT-5 et règles expertes"""
    
    def __init__(self):
        self.client = AzureOpenAI(
            api_key=os.getenv("AZURE_OPENAI_KEY", "0e1141969928462bbbf342678c01079e"),
            api_version=os.getenv("AZURE_OPENAI_API_VERSION", "2024-12-01-preview"),
            azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT", "https://voxist-gpt-eastus2.openai.azure.com/")
        )
        self.model = os.getenv("AZURE_OPENAI_MODEL", "gpt-5")
        self.deployment = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-5-eastus2")
        
        # Patterns regex pour extraction experte
        self.medical_patterns = {
            'uterus_position': [
                r'utérus est (\w+)',
                r'L\'utérus .*?est (\w+)',
            ],
            'hysterometry': [
                r'(\d+(?:[.,]\d+)?)\s*(?:d\'|de\s+)?hystérométrie',
                r'hystérométrie\s*:?\s*(\d+(?:[.,]\d+)?)',
            ],
            'endometrium': [
                r'(\d+(?:[.,]\d+)?)\s*(?:d\'|de\s+)?endomètre',
                r'endomètre.*?(\d+(?:[.,]\d+)?)',
            ],
            'zone_jonctionnelle': [
                r'zone jonctionnelle\s+(\w+)',
                r'(\w+)\s+zone jonctionnelle',
            ],
            'myomas_fibrome': [
                r'pas de (fibrome|myome)s?',
                r'(fibrome|myome)s?\s+myomètre\s+pas de (fibrome|myome)s?',
                r'sans (fibrome|myome)s?',
                r'absence.*?(fibrome|myome)s?',
            ],
            'adenomyosis': [
                r'adénomyose\s+(\w+)',
                r'(\w+)\s+d\'adénomyose',
            ],
        }

    def extract_medical_entities(self, transcription: str) -> ExtractedData:
        """
        Extraction principale utilisant GPT-5 + NER expert amélioré
        """
        logger.info("🚀 Début de l'extraction d'entités médicales")
        
        # Étape 1: Préprocessing du texte
        cleaned_text = self._preprocess_text(transcription)
        logger.info(f"📝 Texte nettoyé: {cleaned_text[:100]}...")
        
        # Étape 2: Extraction structurée des ovaires (nouvelle méthode)
        ovary_data = self._extract_ovaries_structured(cleaned_text)
        
        # Étape 3: Extraction avec GPT-5
        gpt_entities = self._extract_with_gpt5(cleaned_text)
        
        # Étape 4: Extraction avec NER expert (fallback et validation)
        expert_entities = self._extract_with_expert_ner(cleaned_text)
        
        # Étape 5: Fusion intelligente avec priorité aux ovaires structurés
        final_data = self._merge_extraction_results_improved(gpt_entities, expert_entities, ovary_data, cleaned_text)
        
        # Étape 6: Validation et calcul de confiance
        final_data.extraction_confidence = self._calculate_confidence(final_data)
        final_data.missing_fields = self._identify_missing_fields(final_data)
        
        logger.info(f"✅ Extraction terminée - Confiance: {final_data.extraction_confidence:.2f}")
        
        return final_data

    def _extract_ovaries_structured(self, text: str) -> Dict[str, Dict[str, str]]:
        """
        Extraction structurée des ovaires avec analyse contextuelle améliorée
        """
        logger.info("🔍 Extraction structurée des ovaires")
        
        ovary_data = {
            'right': {'dimensions': None, 'cfa': None, 'accessibility': None},
            'left': {'dimensions': None, 'cfa': None, 'accessibility': None}
        }
        
        # 1. Recherche explicite ovaire droit
        right_match = re.search(
            r'ovaire droit\s+mesure\s+(\d+(?:[.,]\d+)?)\s*(?:fois|x)\s*(\d+(?:[.,]\d+)?)\s*mm.*?(\d+)\s*follicules',
            text, re.IGNORECASE | re.DOTALL
        )
        
        if right_match:
            ovary_data['right']['dimensions'] = f"{right_match.group(1)} x {right_match.group(2)} mm"
            ovary_data['right']['cfa'] = right_match.group(3)
            logger.info(f"✅ Ovaire droit trouvé: {ovary_data['right']}")
        
        # 2. Recherche ovaire gauche avec analyse contextuelle
        # Pattern principal pour les dimensions
        left_dim_patterns = [
            r'ovaire gauche.*?mesure\s+(\d+(?:[.,]\d+)?)\s*(?:fois|x)\s*(\d+(?:[.,]\d+)?)',
            r'il mesure\s+(\d+(?:[.,]\d+)?)\s*(?:fois|x)\s*(\d+(?:[.,]\d+)?)',  # référence contextuelle
        ]
        
        for pattern in left_dim_patterns:
            match = re.search(pattern, text, re.IGNORECASE)
            if match:
                ovary_data['left']['dimensions'] = f"{match.group(1)} x {match.group(2)} mm"
                logger.info(f"✅ Dimensions ovaire gauche trouvées: {ovary_data['left']['dimensions']}")
                break
        
        # 3. Extraction CFA avec analyse contextuelle
        cfa_matches = list(re.finditer(r'(\d+)\s*follicules', text, re.IGNORECASE))
        cfa_siege_matches = list(re.finditer(r'siège de.*?(\d+)\s*follicules', text, re.IGNORECASE))
        
        # Combiner tous les CFA trouvés
        all_cfa = []
        for match in cfa_matches:
            all_cfa.append((match.group(1), match.start(), 'follicules'))
        for match in cfa_siege_matches:
            all_cfa.append((match.group(1), match.start(), 'siège'))
        
        # Trier par position dans le texte
        all_cfa.sort(key=lambda x: x[1])
        
        # Attribution contextuelle des CFA
        if len(all_cfa) >= 2:
            # Le premier CFA est généralement pour l'ovaire droit
            if not ovary_data['right']['cfa']:
                ovary_data['right']['cfa'] = all_cfa[0][0]
            
            # Le dernier CFA ou celui avec "siège" est généralement pour l'ovaire gauche
            for cfa_value, pos, cfa_type in reversed(all_cfa):
                if cfa_type == 'siège' or pos > all_cfa[0][1]:
                    ovary_data['left']['cfa'] = cfa_value
                    break
            
            logger.info(f"✅ CFA attribués - Droit: {ovary_data['right']['cfa']}, Gauche: {ovary_data['left']['cfa']}")
        
        elif len(all_cfa) == 1:
            # Un seul CFA - analyser le contexte
            cfa_value = all_cfa[0][0]
            cfa_context = text[max(0, all_cfa[0][1]-50):all_cfa[0][1]+50].lower()
            
            if 'gauche' in cfa_context or 'siège' in cfa_context:
                ovary_data['left']['cfa'] = cfa_value
            else:
                ovary_data['right']['cfa'] = cfa_value
        
        # 4. Extraction accessibilité avec analyse contextuelle améliorée
        # Ovaire gauche - accessibilité difficile
        if re.search(r'ovaire gauche.*?accès difficile', text, re.IGNORECASE) or \
           re.search(r'd\'accès difficile à rétro-utérin', text, re.IGNORECASE):
            ovary_data['left']['accessibility'] = 'difficile rétro-utérine'
        
        # Analyse "par contre l'autre il est normal"
        if re.search(r'par contre l\'autre il est normal', text, re.IGNORECASE):
            # Dans le contexte médical, si l'ovaire gauche est difficile, "l'autre" = ovaire droit
            if ovary_data['left']['accessibility'] == 'difficile rétro-utérine':
                ovary_data['right']['accessibility'] = 'normale'
            else:
                # Analyse du contexte précédent pour déterminer quel ovaire est "l'autre"
                context_before = text[:text.find('par contre')].lower() if 'par contre' in text.lower() else text.lower()
                if 'gauche' in context_before[-100:]:
                    ovary_data['right']['accessibility'] = 'normale'
                else:
                    ovary_data['left']['accessibility'] = 'normale'
        
        logger.info(f"🎯 Données ovaires structurées: {ovary_data}")
        return ovary_data

    def _preprocess_text(self, text: str) -> str:
        """Prétraitement du texte médical"""
        # Nettoyage des espaces multiples
        text = re.sub(r'\s+', ' ', text.strip())
        
        # Correction des nombres séparés (ex: "7. 8" -> "7.8")
        text = re.sub(r'(\d+)\.\s+(\d+)', r'\1.\2', text)
        text = re.sub(r'(\d+)\s+(\d+)', lambda m: f"{m.group(1)}.{m.group(2)}" if len(m.group(2)) == 1 else f"{m.group(1)} {m.group(2)}", text)
        
        # Normalisation des unités
        text = text.replace('fois', 'x')
        
        return text

    def _extract_with_gpt5(self, text: str) -> ExtractedData:
        """Extraction avec GPT-5 améliorée"""
        prompt = self._build_improved_ner_prompt(text)
        
        try:
            response = self.client.chat.completions.create(
                model=self.deployment,
                messages=[
                    {
                        "role": "system",
                        "content": self._get_improved_medical_system_prompt()
                    },
                    {
                        "role": "user",
                        "content": prompt
                    }
                ],
                #temperature=0.1,
                response_format={"type": "json_object"}
            )
            
            json_response = response.choices[0].message.content.strip()
            data_dict = json.loads(json_response)
            
            return self._dict_to_extracted_data(data_dict)
            
        except Exception as e:
            logger.error(f"❌ Erreur extraction GPT-5: {e}")
            return ExtractedData()

    def _build_improved_ner_prompt(self, text: str) -> str:
        """Construction du prompt NER amélioré pour GPT-5"""
        return f"""
        Tu es un expert en analyse d'échographies gynécologiques. Extrais précisément les entités médicales de cette transcription en analysant TRÈS ATTENTIVEMENT le contexte pour les ovaires.

        TRANSCRIPTION: "{text}"

        RÈGLES CRITIQUES POUR LES OVAIRES:
        1. "L'ovaire droit mesure X x Y mm, Z follicules" -> ovaire droit
        2. "il mesure X x Y mm siège de Z follicules" après mention de l'ovaire gauche -> ovaire gauche  
        3. "par contre l'autre il est normal" = généralement l'ovaire droit si le gauche est difficile d'accès
        4. "siège de X follicules" = généralement ovaire gauche
        5. Premier CFA mentionné = généralement ovaire droit, dernier = ovaire gauche

        Extrais au format JSON strict:

        {{
            "uterus_position": "antéversé/rétroversé/intermédiaire ou null",
            "uterus_size": "dimension en cm ou null", 
            "hysterometry": "valeur en mm ou null",
            "endometrium_thickness": "valeur en mm ou null",
            "myomas_present": true/false/null,
            "zone_jonctionnelle_status": "normale/épaissie ou null",
            "adenomyosis_type": "diffuse/focale/absente ou null",
            "right_ovary_dimensions": "longueur x largeur avec unité ou null",
            "right_ovary_cfa": "nombre follicules ou null",
            "right_ovary_accessibility": "normale/aisée/difficile/rétro-utérine ou null",
            "left_ovary_dimensions": "longueur x largeur avec unité ou null", 
            "left_ovary_cfa": "nombre follicules ou null",
            "left_ovary_accessibility": "normale/aisée/difficile/rétro-utérine ou null",
            "doppler_ip": "valeur IP ou null",
            "doppler_ir": "valeur IR ou null"
        }}

        ANALYSE LE CONTEXTE COMPLET pour différencier ovaire droit/gauche.
        Réponds uniquement avec le JSON, sans explication.
        """

    def _get_improved_medical_system_prompt(self) -> str:
        """Prompt système médical amélioré pour GPT-5"""
        return """Tu es un système expert en NER (Named Entity Recognition) médical spécialisé dans les échographies gynécologiques.
        
        MISSION CRITIQUE: Extraire avec une précision maximale les entités médicales, avec une attention particulière à la DISAMBIGUATION DES OVAIRES.
        
        EXPERTISE SPÉCIFIQUE OVAIRES:
        - Analyse contextuelle: "L'ovaire droit mesure..." vs "il mesure..." (référence à l'ovaire précédemment mentionné)
        - Références croisées: "l'autre", "par contre" nécessitent une analyse du contexte complet
        - Attribution CFA: Premier mentionné = généralement droit, "siège de" = généralement gauche
        - Accessibilité: "difficile rétro-utérin" est souvent l'ovaire gauche, "normal" l'autre
        
        RÈGLES D'OR:
        1. Lis TOUT le texte avant d'attribuer les mesures aux ovaires
        2. Utilise les indices contextuels (ordre, proximité, références)
        3. Ne mélange JAMAIS les données entre ovaire droit et gauche
        4. Si ambiguïté, privilégie l'ordre d'apparition dans le texte médical standard
        
        Tu dois être extrêmement précis dans la différenciation ovaire droit/gauche."""

    def _extract_with_expert_ner(self, text: str) -> ExtractedData:
        """Extraction avec NER expert (regex + règles)"""
        extracted = ExtractedData()
        
        # Extraction position utérus
        extracted.uterus_position = self._extract_pattern(text, 'uterus_position')
        
        # Extraction hystérométrie
        extracted.hysterometry = self._extract_pattern(text, 'hysterometry')
        
        # Extraction endomètre
        extracted.endometrium_thickness = self._extract_pattern(text, 'endometrium')
        
        # Extraction zone jonctionnelle
        zone_jonc = self._extract_zone_jonctionnelle(text)
        if zone_jonc:
            extracted.zone_jonctionnelle_status = zone_jonc
        
        # Extraction myomes/fibromes
        myomas_status = self._extract_myomas_status(text)
        if myomas_status is not None:
            extracted.myomas_present = myomas_status
        
        # Extraction Doppler
        doppler_values = self._extract_doppler(text)
        extracted.doppler_ip = doppler_values.get('ip')
        extracted.doppler_ir = doppler_values.get('ir')
        
        # Extraction adénomyose
        extracted.adenomyosis_type = self._extract_pattern(text, 'adenomyosis')
        
        return extracted

    def _extract_zone_jonctionnelle(self, text: str) -> Optional[str]:
        """Extraction du statut de la zone jonctionnelle"""
        if re.search(r'zone jonctionnelle\s+épaissie', text, re.IGNORECASE):
            return "épaissie"
        elif re.search(r'épaissie.*?zone jonctionnelle', text, re.IGNORECASE):
            return "épaissie"
        elif re.search(r'zone jonctionnelle\s+normale', text, re.IGNORECASE):
            return "normale"
        
        return None

    def _extract_myomas_status(self, text: str) -> Optional[bool]:
        """Extraction du statut des myomes/fibromes"""
        negative_patterns = [
            r'pas de (fibrome|myome)s?',
            r'sans (fibrome|myome)s?',
            r'absence.*?(fibrome|myome)s?',
            r'(fibrome|myome)s?\s+myomètre\s+pas de (fibrome|myome)s?',
        ]
        
        for pattern in negative_patterns:
            if re.search(pattern, text, re.IGNORECASE):
                return False
        
        positive_patterns = [
            r'présence.*?(fibrome|myome)s?',
            r'(fibrome|myome)s?\s+présents?',
            r'multiples (fibrome|myome)s?',
        ]
        
        for pattern in positive_patterns:
            if re.search(pattern, text, re.IGNORECASE):
                return True
        
        return None

    def _extract_pattern(self, text: str, pattern_key: str) -> Optional[str]:
        """Extraction avec patterns regex"""
        patterns = self.medical_patterns.get(pattern_key, [])
        
        for pattern in patterns:
            match = re.search(pattern, text, re.IGNORECASE)
            if match:
                return match.group(1)
        
        return None

    def _extract_doppler(self, text: str) -> Dict[str, str]:
        """Extraction valeurs Doppler"""
        doppler = {}
        
        # Pattern pour "Doppler : IP X - IR Y"
        doppler_match = re.search(r'Doppler\s*:?\s*IP\s*(\d+(?:[.,]\d+)?)\s*-?\s*IR\s*(\d+(?:[.,]\d+)?)', text, re.IGNORECASE)
        
        if doppler_match:
            doppler['ip'] = doppler_match.group(1)
            doppler['ir'] = doppler_match.group(2)
        else:
            # Recherche séparée
            ip_match = re.search(r'IP\s*:?\s*(\d+(?:[.,]\d+)?)', text, re.IGNORECASE)
            if ip_match:
                doppler['ip'] = ip_match.group(1)
            
            ir_match = re.search(r'IR\s*:?\s*(\d+(?:[.,]\d+)?)', text, re.IGNORECASE)
            if ir_match:
                doppler['ir'] = ir_match.group(1)
        
        return doppler

    def _merge_extraction_results_improved(self, gpt_data: ExtractedData, expert_data: ExtractedData, ovary_data: Dict, text: str) -> ExtractedData:
        """Fusion intelligente avec priorité aux données ovaires structurées"""
        merged = ExtractedData()
        
        # Priorité: données ovaires structurées > GPT-5 > Expert NER
        non_ovary_fields = [
            'uterus_position', 'uterus_size', 'hysterometry',
            'endometrium_thickness', 'adenomyosis_type', 'zone_jonctionnelle_status',
            'myomas_present', 'doppler_ip', 'doppler_ir'
        ]
        
        # Fusion des champs non-ovaires
        for field in non_ovary_fields:
            gpt_value = getattr(gpt_data, field, None)
            expert_value = getattr(expert_data, field, None)
            
            if gpt_value is not None and str(gpt_value).strip() and str(gpt_value) != 'null':
                setattr(merged, field, gpt_value)
            elif expert_value is not None and str(expert_value).strip():
                setattr(merged, field, expert_value)
        
        # Attribution prioritaire des données ovaires structurées
        if ovary_data['right']['dimensions']:
            merged.right_ovary_dimensions = ovary_data['right']['dimensions']
        elif gpt_data.right_ovary_dimensions:
            merged.right_ovary_dimensions = gpt_data.right_ovary_dimensions
        
        if ovary_data['right']['cfa']:
            merged.right_ovary_cfa = ovary_data['right']['cfa']
        elif gpt_data.right_ovary_cfa:
            merged.right_ovary_cfa = gpt_data.right_ovary_cfa
            
        if ovary_data['right']['accessibility']:
            merged.right_ovary_accessibility = ovary_data['right']['accessibility']
        elif gpt_data.right_ovary_accessibility:
            merged.right_ovary_accessibility = gpt_data.right_ovary_accessibility
        
        if ovary_data['left']['dimensions']:
            merged.left_ovary_dimensions = ovary_data['left']['dimensions']
        elif gpt_data.left_ovary_dimensions:
            merged.left_ovary_dimensions = gpt_data.left_ovary_dimensions
            
        if ovary_data['left']['cfa']:
            merged.left_ovary_cfa = ovary_data['left']['cfa']
        elif gpt_data.left_ovary_cfa:
            merged.left_ovary_cfa = gpt_data.left_ovary_cfa
            
        if ovary_data['left']['accessibility']:
            merged.left_ovary_accessibility = ovary_data['left']['accessibility']
        elif gpt_data.left_ovary_accessibility:
            merged.left_ovary_accessibility = gpt_data.left_ovary_accessibility
        
        # Post-traitement contextuel
        merged = self._post_process_contextual(merged, text)
        
        return merged

    def _post_process_contextual(self, data: ExtractedData, text: str) -> ExtractedData:
        """Post-traitement contextuel pour corriger les erreurs spécifiques"""
        
        # Correction unités doublées
        if data.hysterometry and 'mm mm' in str(data.hysterometry):
            data.hysterometry = str(data.hysterometry).replace(' mm mm', ' mm')
        
        if data.endometrium_thickness and 'mm mm' in str(data.endometrium_thickness):
            data.endometrium_thickness = str(data.endometrium_thickness).replace(' mm mm', ' mm')
        
        # Correction CFA doublés
        if data.right_ovary_cfa and 'follicules follicules' in str(data.right_ovary_cfa):
            data.right_ovary_cfa = str(data.right_ovary_cfa).replace(' follicules follicules', '')
            
        if data.left_ovary_cfa and 'follicules follicules' in str(data.left_ovary_cfa):
            data.left_ovary_cfa = str(data.left_ovary_cfa).replace(' follicules follicules', '')
        
        # Ajout d'unités manquantes
        if data.left_ovary_dimensions and not ('mm' in str(data.left_ovary_dimensions) or 'cm' in str(data.left_ovary_dimensions)):
            if re.match(r'\d+\s*x\s*\d+$', str(data.left_ovary_dimensions).strip()):
                data.left_ovary_dimensions = str(data.left_ovary_dimensions) + ' mm'
                
        if data.right_ovary_dimensions and not ('mm' in str(data.right_ovary_dimensions) or 'cm' in str(data.right_ovary_dimensions)):
            if re.match(r'\d+\s*x\s*\d+$', str(data.right_ovary_dimensions).strip()):
                data.right_ovary_dimensions = str(data.right_ovary_dimensions) + ' mm'
        
        return data

    def _calculate_confidence(self, data: ExtractedData) -> float:
        """Calcul score de confiance basé sur la complétude"""
        important_fields = [
            'uterus_position', 'hysterometry', 'endometrium_thickness',
            'right_ovary_dimensions', 'left_ovary_dimensions',
            'right_ovary_cfa', 'left_ovary_cfa',
            'doppler_ip', 'doppler_ir'
        ]
        
        filled_fields = 0
        for field in important_fields:
            value = getattr(data, field, None)
            if value is not None and str(value).strip():
                filled_fields += 1
        
        return filled_fields / len(important_fields)

    def _identify_missing_fields(self, data: ExtractedData) -> List[str]:
        """Identifie les champs manquants"""
        missing = []
        
        field_mapping = {
            'uterus_position': 'Position utérus',
            'hysterometry': 'Hystérométrie',
            'endometrium_thickness': 'Épaisseur endomètre',
            'zone_jonctionnelle_status': 'Zone jonctionnelle',
            'myomas_present': 'Présence myomes',
            'right_ovary_dimensions': 'Taille ovaire droit',
            'left_ovary_dimensions': 'Taille ovaire gauche',
            'right_ovary_cfa': 'CFA ovaire droit',
            'left_ovary_cfa': 'CFA ovaire gauche',
            'right_ovary_accessibility': 'Accessibilité ovaire droit',
            'left_ovary_accessibility': 'Accessibilité ovaire gauche',
            'doppler_ip': 'IP Doppler',
            'doppler_ir': 'IR Doppler'
        }
        
        for field, description in field_mapping.items():
            value = getattr(data, field, None)
            if value is None or (isinstance(value, str) and not value.strip()):
                missing.append(description)
        
        return missing

    def _dict_to_extracted_data(self, data_dict: Dict[str, Any]) -> ExtractedData:
        """Convertit dictionnaire JSON en ExtractedData"""
        extracted = ExtractedData()
        
        field_mapping = {
            'uterus_position': 'uterus_position',
            'uterus_size': 'uterus_size', 
            'hysterometry': 'hysterometry',
            'endometrium_thickness': 'endometrium_thickness',
            'myomas_present': 'myomas_present',
            'zone_jonctionnelle_status': 'zone_jonctionnelle_status',
            'adenomyosis_type': 'adenomyosis_type',
            'right_ovary_dimensions': 'right_ovary_dimensions',
            'right_ovary_cfa': 'right_ovary_cfa',
            'right_ovary_accessibility': 'right_ovary_accessibility',
            'left_ovary_dimensions': 'left_ovary_dimensions',
            'left_ovary_cfa': 'left_ovary_cfa', 
            'left_ovary_accessibility': 'left_ovary_accessibility',
            'doppler_ip': 'doppler_ip',
            'doppler_ir': 'doppler_ir'
        }
        
        for json_key, attr_name in field_mapping.items():
            value = data_dict.get(json_key)
            if value is not None and str(value).strip() and str(value) != 'null':
                setattr(extracted, attr_name, value)
        
        return extracted

    def print_extraction_report(self, data: ExtractedData) -> str:
        """Génère un rapport d'extraction formaté"""
        report = " RAPPORT D'EXTRACTION MÉDICALE\n"
        report += "=" * 50 + "\n\n"
        
        # Utérus
        report += " UTÉRUS:\n"
        report += f"  Position: {data.uterus_position or '❌ Non trouvé'}\n"
        report += f"  Taille: {data.uterus_size or '❌ Non trouvé'}\n"
        report += f"  Hystérométrie: {data.hysterometry or '❌ Non trouvé'}\n"
        
        # Endomètre
        report += f"\n ENDOMÈTRE:\n"
        report += f"  Épaisseur: {data.endometrium_thickness or '❌ Non trouvé'}\n"
        
        # Zone jonctionnelle
        report += f"\n ZONE JONCTIONNELLE:\n"
        report += f"  Status: {data.zone_jonctionnelle_status or '❌ Non trouvé'}\n"
        report += f"  Myomes présents: {data.myomas_present if data.myomas_present is not None else '❌ Non trouvé'}\n"
        report += f"  Adénomyose: {data.adenomyosis_type or '❌ Non trouvé'}\n"
        
        # Ovaires
        report += f"\n OVAIRE DROIT:\n"
        report += f"  Dimensions: {data.right_ovary_dimensions or '❌ Non trouvé'}\n"
        report += f"  CFA: {data.right_ovary_cfa or '❌ Non trouvé'} follicules\n"
        report += f"  Accessibilité: {data.right_ovary_accessibility or '❌ Non trouvé'}\n"
        
        report += f"\n OVAIRE GAUCHE:\n"
        report += f"  Dimensions: {data.left_ovary_dimensions or '❌ Non trouvé'}\n"
        report += f"  CFA: {data.left_ovary_cfa or '❌ Non trouvé'} follicules\n"
        report += f"  Accessibilité: {data.left_ovary_accessibility or '❌ Non trouvé'}\n"
        
        # Doppler
        report += f"\n DOPPLER:\n"
        report += f"  IP: {data.doppler_ip or '❌ Non trouvé'}\n"
        report += f"  IR: {data.doppler_ir or '❌ Non trouvé'}\n"
        
        # Statistiques
        report += f"\n STATISTIQUES:\n"
        report += f"  Score de confiance: {data.extraction_confidence:.1%}\n"
        report += f"  Champs manquants: {len(data.missing_fields)}\n"
        
        if data.missing_fields:
            report += f"  Détails manquants: {', '.join(data.missing_fields)}\n"
        
        return report

def test_extraction():
    """Test de l'extraction avec le cas problématique"""
    # Transcription à analyser
    transcription = """Compte rendu classique. L'utérus est antéversé de taille 7,8 cm 60 d'hystérométrie 
    3,7 d'endomètre triangulaire zone jonctionnelle épaissie focale d'adénomyose diffuse fibromes 
    myomètre pas de fibromes. Le col voulut le laisser comme il est la morphologie triangulaire. 
    L'ovaire droit mesure 26 x 20 mm, 5 follicules. L'ovaire gauche accessibilité au maître rétro 
    thérape par contre l'autre il est normal il mesure 25 x 19 mm siège de CFA : 22 follicules. 
    Le Doppler : IP 3,24 - IR 0,91 et le reste tout en fait qui est l'ovaire gauche d'accès 
    difficile à rétro-utérin."""

    # Création de l'agent
    agent = MedicalNERAgent()

    # Extraction
    result = agent.extract_medical_entities(transcription)

    # Affichage du rapport
    print(agent.print_extraction_report(result))
    
    # Test spécifique pour vérifier la correction
    print("\n🔍 VÉRIFICATION SPÉCIFIQUE DES OVAIRES:")
    print(f"Ovaire droit - Dimensions: {result.right_ovary_dimensions}")
    print(f"Ovaire droit - CFA: {result.right_ovary_cfa}")
    print(f"Ovaire droit - Accessibilité: {result.right_ovary_accessibility}")
    print(f"Ovaire gauche - Dimensions: {result.left_ovary_dimensions}")  
    print(f"Ovaire gauche - CFA: {result.left_ovary_cfa}")
    print(f"Ovaire gauche - Accessibilité: {result.left_ovary_accessibility}")


if __name__ == "__main__":
    test_extraction()