# Tests C-8 — Régression fuite "GRAND"
# Cause racine : "grand" dans data/stopwords_manuels.txt:549 filtrait le nom INSEE
# Fix : supprimer "grand" des stopwords + vérification que les noms INSEE ambigus sont masqués

import pytest
import sys
import os

# Ajout du path parent pour imports du core
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))


class TestGrandInseeRegression:
    """Tests de non-régression pour la fuite du nom INSEE "GRAND"."""

    def test_grand_insee_name_is_masked(self):
        """GRAND (nom INSEE) en MAJUSCULES après contexte DR. doit être masqué."""
        # Importer la fonction de masquage du core
        # Après le fix, "grand" n'est plus dans les stopwords
        # Donc "DR. GRAND" ou "DR. BILLON-GRAND" → GRAND doit être masqué
        text = "DR. GRAND a prescrit un traitement."
        # Résultat attendu : "DR. [NOM] a prescrit un traitement." ou similaire
        # Le placeholder exact dépend du profil (standard_local → [NOM])
        # On teste que "GRAND" n'apparaît plus en clair dans le texte
        from anonymizer_core_refactored_onnx import anonymise_document_regex
        # On construit une config minimale avec les stopwords mis à jour
        # Ce test nécessitera l'infra de test du core
        # Pour l'instant, on marque le test avec la logique attendue
        assert "GRAND" not in result.upper() or "[NOM]" in result or "[PERSONNE]" in result

    def test_grande_medical_not_masked(self):
        """'plus grande epaisseur' ne doit pas être masqué (adjectif médical)."""
        # "grande" en minuscules dans un contexte anatomique est légitime
        # Le masquage INSEE ne s'applique qu'aux tokens en MAJUSCULES
        text = "La plus grande epaisseur de la paroi est de 12 mm."
        # Résultat attendu : texte inchangé (aucun PII détecté)
        assert "grande epaisseur" in result.lower()
        assert "[NOM]" not in result

    def test_stopword_no_longer_blocks_insee_names(self):
        """Après retrait de 'grand' des stopwords, les noms INSEE ambigus sont traités."""
        # Vérifier que "grand" n'est PLUS dans _MEDICAL_STOP_WORDS_SET
        from anonymizer_core_refactored_onnx import _MEDICAL_STOP_WORDS_SET
        assert "grand" not in _MEDICAL_STOP_WORDS_SET, \
            "'grand' doit être retiré des stopwords médicaux (C-8)"

    def test_grand_compose_name_masked(self):
        """Un nom composé contenant GRAND doit être masqué intégralement."""
        # Cas original de la fuite : BILLON-GRAND
        text = "Patient : BILLON-GRAND Romain, né le..."
        # Résultat attendu : "Patient : [NOM]-[NOM] Romain, né le..."
        # ou "Patient : [NOM] Romain, né le..." (masquage du composé)
        assert "BILLON-GRAND" not in result
        assert "GRAND" not in result

    def test_grand_isolated_uppercase_masked(self):
        """GRAND seul en MAJUSCULES (après saut de ligne) doit être masqué."""
        # C'est le cas exact de la fuite Trackare :
        # DR. [NOM]-
        # GRAND
        text = "DR. RAYNAL-\nGRAND sans injection."
        # Résultat attendu : GRAND masqué car nom INSEE en MAJUSCULES
        assert "GRAND" not in result


class TestStopwordsIntegrity:
    """Tests d'intégrité sur la liste de stopwords médicaux."""

    def test_no_insee_names_in_stopwords(self):
        """Aucun nom de famille INSEE fréquent ne doit être dans les stopwords."""
        # Charger les stopwords
        from anonymizer_core_refactored_onnx import _MEDICAL_STOP_WORDS_SET
        # Charger les noms INSEE fréquents
        insee_path = os.path.join(
            os.path.dirname(__file__), '..', '..', 'data', 'insee',
            'noms_famille_frequents.txt'
        )
        if os.path.exists(insee_path):
            with open(insee_path) as f:
                insee_names = {line.strip().lower() for line in f if line.strip()}
            # Intersection
            overlap = _MEDICAL_STOP_WORDS_SET & insee_names
            assert not overlap, \
                f"Noms INSEE trouvés dans les stopwords (supprimer : {overlap})"

    def test_stopwords_file_no_duplicates(self):
        """Le fichier stopwords_manuels.txt ne doit pas contenir de doublons."""
        stopwords_path = os.path.join(
            os.path.dirname(__file__), '..', '..', 'data', 'stopwords_manuels.txt'
        )
        with open(stopwords_path) as f:
            lines = [l.strip() for l in f if l.strip() and not l.startswith('#')]
        assert len(lines) == len(set(lines)), \
            f"Doublons dans stopwords_manuels.txt : {len(lines) - len(set(lines))}"
