from __future__ import annotations

import unittest
from pathlib import Path

from app.case_epicrisis.application.utils import (
    build_ayudas_diagnosticas,
    build_pdf_primary_ayudas_diagnosticas,
    build_procedimientos_clinicos,
    extract_incapacidad_clinica,
    format_ayuda_diagnostica_interpretacion_exportable,
    format_ayuda_diagnostica_nombre_exportable,
    normalize_context_payload,
)
from app.services.clinical_processing import normalizar_medicamento_canonico


class ClinicalProcedureConsolidationTest(unittest.TestCase):
    def test_classifies_cups_and_marks_invoice_only_support(self) -> None:
        procedures = build_procedimientos_clinicos(
            {
                "procedimientos_hc": ["151001 Consulta de primera vez"],
                "procedimientos_factura": [
                    {"codigo_cups": "010101", "codigo_soat": "S-1", "descripcion": "Biopsia"}
                ],
                "codigos_desde_soat": [],
                "pdf_draft": {},
            }
        )

        by_description = {item["descripcion"]: item for item in procedures}
        self.assertEqual(by_description["Consulta de primera vez"]["clasificacion"], "no_quirurgico")
        self.assertTrue(by_description["Consulta de primera vez"]["soporte_clinico"])
        self.assertEqual(by_description["Biopsia"]["clasificacion"], "quirurgico")
        self.assertFalse(by_description["Biopsia"]["soporte_clinico"])

    def test_manual_classification_has_precedence(self) -> None:
        base = build_procedimientos_clinicos(
            {"procedimientos_hc": ["151001 Consulta"], "pdf_draft": {}}
        )[0]
        result = build_procedimientos_clinicos(
            {
                "procedimientos_hc": ["151001 Consulta"],
                "pdf_draft": {
                    "procedure_classification_overrides": {base["key"]: "quirurgico"}
                },
            }
        )[0]
        self.assertEqual(result["clasificacion"], "quirurgico")
        self.assertTrue(result["clasificacion_manual"])

    def test_legacy_context_gets_canonical_procedures(self) -> None:
        context = normalize_context_payload({"procedimientos_hc": ["Procedimiento sin código"]})
        self.assertEqual(context["procedimientos_clinicos"][0]["clasificacion"], "sin_clasificar")


class ClinicalExtractionRulesTest(unittest.TestCase):
    def test_immediate_medication_defaults_missing_quantity_to_one(self) -> None:
        medication = normalizar_medicamento_canonico(
            {"medicamento": "Dipirona", "dosis": "1 g IV aplicar ahora"}
        )
        self.assertEqual(medication["cantidad"], "1")

    def test_explicit_quantity_is_preserved(self) -> None:
        medication = normalizar_medicamento_canonico(
            {"medicamento": "Dipirona", "dosis": "aplicar ahora", "cantidad": "2"}
        )
        self.assertEqual(medication["cantidad"], "2")

    def test_extracts_only_ordered_incapacity(self) -> None:
        ordered = extract_incapacidad_clinica(
            {"historia": {"texto_extraido": "Se ordena incapacidad por 3 días."}}
        )
        historical = extract_incapacidad_clinica(
            {"historia": {"texto_extraido": "Antecedente de incapacidad hace un año."}}
        )
        self.assertTrue(ordered["ordenada"])
        self.assertEqual(ordered["duracion"], "3")
        self.assertFalse(historical["ordenada"])


class DiagnosticAidExportTest(unittest.TestCase):
    def test_invoice_aid_uses_code_and_description_as_label_not_interpretation(self) -> None:
        context = {
            "factura": {
                "_id": "fac-1",
                "factura_json": {
                    "servicios_procedimientos": {
                        "imagenologia": [
                            {
                                "estudio": "21602",
                                "descripcion": "Portátiles con fluoroscopia y/o intensificador de imagen",
                            }
                        ],
                        "examenes_laboratorio": [],
                    }
                },
            }
        }

        ayuda = build_ayudas_diagnosticas(context)[0]

        self.assertEqual(
            ayuda["nombre"],
            "21602 - Portátiles con fluoroscopia y/o intensificador de imagen",
        )
        self.assertEqual(ayuda["concepto"], "No interpretado")
        self.assertFalse(ayuda["interpretado"])

        pdf_ayuda = build_pdf_primary_ayudas_diagnosticas({"ayudas_diagnosticas": [ayuda]})[0]
        self.assertEqual(
            format_ayuda_diagnostica_nombre_exportable(pdf_ayuda),
            "21602 - Portátiles con fluoroscopia y/o intensificador de imagen",
        )
        self.assertEqual(format_ayuda_diagnostica_interpretacion_exportable(pdf_ayuda), "")

    def test_legacy_invoice_aid_moves_description_from_concept_to_export_label(self) -> None:
        legacy = {
            "tipo": "imagen",
            "nombre": "21602",
            "concepto": "Portátiles con fluoroscopia y/o intensificador de imagen",
            "fuente": "factura",
            "interpretado": False,
            "facturado": True,
            "exportable": True,
        }

        self.assertEqual(
            format_ayuda_diagnostica_nombre_exportable(legacy),
            "21602 - Portátiles con fluoroscopia y/o intensificador de imagen",
        )
        self.assertEqual(format_ayuda_diagnostica_interpretacion_exportable(legacy), "")


class PdfClinicalExportContractTest(unittest.TestCase):
    def test_procedure_table_exports_cups_without_soat_column(self) -> None:
        pdf_js = Path("static/js/epicrisis/pdf.js").read_text(encoding="utf-8")

        self.assertIn('renderPdfTableContent(["Código CUPS", "Procedimiento"], rows)', pdf_js)
        self.assertNotIn('renderPdfTableContent(["Código CUPS", "Código SOAT", "Procedimiento"], rows)', pdf_js)
        self.assertNotIn("codigoSoat", pdf_js)


if __name__ == "__main__":
    unittest.main()
