"""
Tests pour le mapper CIM-10 / CIM-11.

Exigences: 24.6, 28.1, 28.2
"""

import pytest
from pathlib import Path
from pipeline_mco_pmsi.referentiels.cim11_mapper import CIM11Mapper, CIM11Mapping


@pytest.fixture
def cim11_mapper(tmp_path):
    """Crée un CIM11Mapper avec des mappings de test."""
    # Créer un fichier de mapping de test
    mappings_dir = tmp_path / "mappings"
    mappings_dir.mkdir(parents=True, exist_ok=True)
    
    mapping_file = mappings_dir / "test_mappings.yaml"
    mapping_content = """mappings:
  - cim10_code: "A00.0"
    cim10_label: "Choléra à Vibrio cholerae 01, biovar cholerae"
    cim11_codes: ["1A00.0"]
    cim11_labels: ["Cholera due to Vibrio cholerae O1, biovar cholerae"]
    mapping_type: "exact"
    notes: null
  
  - cim10_code: "K29.0"
    cim10_label: "Gastrite aiguë hémorragique"
    cim11_codes: ["DA40.0"]
    cim11_labels: ["Acute haemorrhagic gastritis"]
    mapping_type: "exact"
    notes: null
  
  - cim10_code: "E11"
    cim10_label: "Diabète sucré non insulino-dépendant"
    cim11_codes: ["5A11", "5A10.1"]
    cim11_labels: ["Type 2 diabetes mellitus", "Type 2 diabetes mellitus with complications"]
    mapping_type: "multiple"
    notes: "Mapping multiple"
"""
    
    with open(mapping_file, "w", encoding="utf-8") as f:
        f.write(mapping_content)
    
    # Créer le mapper et importer les mappings
    mapper = CIM11Mapper(mappings_dir=str(mappings_dir))
    mapper.import_atih_mappings("test_mappings.yaml")
    
    return mapper


def test_import_atih_mappings(cim11_mapper):
    """
    Test que l'import des mappings ATIH fonctionne correctement.
    
    Exigence: 28.1
    """
    # Vérifier que les mappings ont été importés
    assert len(cim11_mapper.cim10_to_cim11) == 3, "3 mappings devraient être importés"
    
    # Vérifier qu'un mapping spécifique existe
    assert "A00.0" in cim11_mapper.cim10_to_cim11
    assert "K29.0" in cim11_mapper.cim10_to_cim11
    assert "E11" in cim11_mapper.cim10_to_cim11


def test_get_cim11_equivalent_exact_mapping(cim11_mapper):
    """
    Test la récupération d'un équivalent CIM-11 pour un mapping exact.
    
    Exigence: 28.1
    """
    mapping = cim11_mapper.get_cim11_equivalent("A00.0")
    
    assert mapping is not None, "Le mapping devrait exister"
    assert mapping.cim10_code == "A00.0"
    assert mapping.cim11_codes == ["1A00.0"]
    assert mapping.mapping_type == "exact"


def test_get_cim11_equivalent_multiple_mapping(cim11_mapper):
    """
    Test la récupération d'un équivalent CIM-11 pour un mapping multiple.
    
    Exigence: 28.1
    """
    mapping = cim11_mapper.get_cim11_equivalent("E11")
    
    assert mapping is not None
    assert len(mapping.cim11_codes) == 2, "Le mapping devrait avoir 2 codes CIM-11"
    assert "5A11" in mapping.cim11_codes
    assert "5A10.1" in mapping.cim11_codes
    assert mapping.mapping_type == "multiple"


def test_get_cim11_equivalent_no_mapping(cim11_mapper):
    """
    Test la récupération d'un équivalent CIM-11 pour un code inexistant.
    
    Exigence: 28.1
    """
    mapping = cim11_mapper.get_cim11_equivalent("Z99.9")
    
    assert mapping is None, "Aucun mapping ne devrait exister pour ce code"


def test_get_cim10_equivalents(cim11_mapper):
    """
    Test la récupération des équivalents CIM-10 d'un code CIM-11 (mapping inverse).
    
    Exigence: 28.2
    """
    cim10_codes = cim11_mapper.get_cim10_equivalents("1A00.0")
    
    assert len(cim10_codes) == 1, "Un code CIM-10 devrait être trouvé"
    assert "A00.0" in cim10_codes


def test_get_cim10_equivalents_multiple(cim11_mapper):
    """
    Test la récupération des équivalents CIM-10 pour un code CIM-11 avec mapping multiple.
    
    Exigence: 28.2
    """
    # Le code CIM-11 "5A11" devrait pointer vers "E11"
    cim10_codes = cim11_mapper.get_cim10_equivalents("5A11")
    
    assert "E11" in cim10_codes


def test_bidirectional_mapping(cim11_mapper):
    """
    Test que les mappings bidirectionnels fonctionnent correctement.
    
    Exigences: 28.1, 28.2
    """
    # CIM-10 → CIM-11
    mapping = cim11_mapper.get_cim11_equivalent("K29.0")
    assert mapping is not None
    cim11_code = mapping.cim11_codes[0]
    assert cim11_code == "DA40.0"
    
    # CIM-11 → CIM-10 (inverse)
    cim10_codes = cim11_mapper.get_cim10_equivalents(cim11_code)
    assert "K29.0" in cim10_codes


def test_search_cim11_by_label(cim11_mapper):
    """
    Test la recherche de codes CIM-11 par libellé.
    
    Exigence: 28.1
    """
    results = cim11_mapper.search_cim11_by_label("Gastrite")
    
    assert len(results) > 0, "Des résultats devraient être trouvés"
    assert any(r.cim10_code == "K29.0" for r in results), "K29.0 devrait être dans les résultats"


def test_get_mapping_statistics(cim11_mapper):
    """
    Test le calcul des statistiques sur les mappings.
    
    Exigence: 28.1
    """
    stats = cim11_mapper.get_mapping_statistics()
    
    assert stats["total_mappings"] == 3
    assert stats["exact_mappings"] == 2
    assert stats["multiple_mappings"] == 1


def test_export_mappings_yaml(cim11_mapper, tmp_path):
    """
    Test l'export des mappings au format YAML.
    
    Exigence: 28.1
    """
    output_file = "exported_mappings.yaml"
    cim11_mapper.export_mappings(output_file, format="yaml")
    
    # Vérifier que le fichier a été créé
    output_path = Path(cim11_mapper.mappings_dir) / output_file
    assert output_path.exists(), "Le fichier exporté devrait exister"


def test_export_mappings_json(cim11_mapper, tmp_path):
    """
    Test l'export des mappings au format JSON.
    
    Exigence: 28.1
    """
    output_file = "exported_mappings.json"
    cim11_mapper.export_mappings(output_file, format="json")
    
    # Vérifier que le fichier a été créé
    output_path = Path(cim11_mapper.mappings_dir) / output_file
    assert output_path.exists(), "Le fichier exporté devrait exister"


def test_import_nonexistent_file(tmp_path):
    """
    Test que l'import d'un fichier inexistant lève une erreur.
    
    Exigence: 28.1
    """
    mapper = CIM11Mapper(mappings_dir=str(tmp_path))
    
    with pytest.raises(FileNotFoundError):
        mapper.import_atih_mappings("nonexistent.yaml")
