"""L1: SQL formula evidence -- concept->formula units (spec D14b).

A concept (e.g. 'fascia pediatrica') maps to a SQL formula (CASE WHEN ...) that
derives it from physical columns. These are reusable, reviewable units: the gate
surfaces a candidate formula, the reviewer approves or rejects it (recorded via
concept_formula_approved / concept_formula_rejected), and approved formulas are
part of the schema-linking artifact. The store is frontmatter-YAML + SQL body.
"""


from datetime import UTC, datetime

from tht.decisions import DecisionRecord
from tht.evidence import formula_store
from tht.evidence.formula_store import ConceptFormula, retrieve_formula, save_formula
from tht.evidence.session import project_session
from tht.session.models import SchemaLinking


def test_formula_retrieval_by_concept(tmp_path):
    f = ConceptFormula(
        concept="fascia pediatrica",
        columns=["data_nascita"],
        sql="CASE WHEN age < 18 THEN 'pediatrica' ELSE 'adulto' END",
        status="reviewed",
        sources=["src1"],
    )
    save_formula(tmp_path, f)
    results = retrieve_formula(tmp_path, "fascia pediatrica")
    assert len(results) == 1
    assert results[0].sql.startswith("CASE WHEN")
    assert results[0].concept == "fascia pediatrica"
    assert results[0].status == "reviewed"
    assert "data_nascita" in results[0].columns


def test_save_and_reload_roundtrip_preserves_sql_body(tmp_path):
    f = ConceptFormula(
        concept="fascia pediatrica",
        columns=["data_nascita"],
        sql="CASE\n  WHEN x THEN 1\nEND",
        status="draft",
        sources=[],
    )
    path = save_formula(tmp_path, f)
    assert path.exists()
    # the file is frontmatter YAML + SQL body
    text = path.read_text()
    assert text.startswith("---")
    assert "concept: fascia pediatrica" in text
    assert "CASE" in text  # SQL body preserved


def test_retrieve_multiple_formulas_for_concept(tmp_path):
    # two competing formulas for the same concept (different sources/status)
    save_formula(tmp_path, ConceptFormula(concept="ablazione", columns=["flag"],
                                          sql="SELECT 1", status="draft", sources=["a"]))
    save_formula(tmp_path, ConceptFormula(concept="ablazione", columns=["testo"],
                                          sql="SELECT 2", status="reviewed", sources=["b"]))
    results = retrieve_formula(tmp_path, "ablazione")
    assert len(results) == 2
    statuses = {r.status for r in results}
    assert statuses == {"draft", "reviewed"}


def test_retrieve_empty_when_no_match(tmp_path):
    save_formula(tmp_path, ConceptFormula(concept="altro", columns=["c"],
                                          sql="SELECT 1", status="reviewed", sources=[]))
    assert retrieve_formula(tmp_path, "inesistente") == []


def test_retrieve_empty_on_missing_dir(tmp_path):
    # no formulas dir at all -> empty list, not error
    assert retrieve_formula(tmp_path / "nope", "anything") == []


def test_concept_formula_decision_types_exist():
    import typing

    from tht.decisions import DecisionType
    args = typing.get_args(DecisionType)
    assert "concept_formula_approved" in args
    assert "concept_formula_rejected" in args


def test_concept_formula_default_status(tmp_path):
    # status has a sensible default so an author can write a draft quickly
    f = ConceptFormula(concept="x", columns=["c"], sql="SELECT 1")
    assert f.status == "draft"  # not yet reviewed
    assert f.sources == []


def test_reviewed_legacy_formula_becomes_curated_formula_with_stable_provenance():
    formula = ConceptFormula(
        concept="fascia pediatrica",
        columns=["clinical.patient.birth_date"],
        sql="CASE WHEN age < 18 THEN 'pediatrica' ELSE 'adulta' END",
        status="reviewed",
        sources=["Regola clinica approvata dal gruppo pediatrico."],
    )

    migrated = formula_store.legacy_formula_to_curated(
        formula, legacy_path="formulas/fascia-pediatrica-1.sql.md",
    )

    assert migrated is not None
    assert migrated.id == "evidence:fascia-pediatrica"
    assert migrated.title == "Fascia pediatrica"
    assert migrated.kind == "formula"
    assert migrated.payload.concept == formula.concept
    assert migrated.payload.columns == ("clinical.patient.birth_date",)
    assert migrated.payload.sql == formula.sql
    assert migrated.provenance.source_file == "source/formulas/fascia-pediatrica-1.sql.md"
    assert migrated.provenance.supporting_excerpts == tuple(formula.sources)
    assert migrated.review_items == ()
    assert formula_store.legacy_formula_to_curated(
        formula, legacy_path="formulas/fascia-pediatrica-1.sql.md",
    ).id == migrated.id


def test_session_formula_proposal_is_versioned_and_is_not_published_evidence(tmp_path):
    linking = SchemaLinking(
        question="Conta i pazienti pediatrici",
        concept_formulas=[{
            "concept": "fascia pediatrica",
            "columns": ["clinical.patient.birth_date"],
            "sql": "CASE WHEN age < 18 THEN 'pediatrica' ELSE 'adulta' END",
            "sources": ["Sintetizzata nella sessione"],
        }],
    )
    decisions = [DecisionRecord(
        seq=9,
        ts=datetime(2026, 8, 25, tzinfo=UTC),
        type="concept_formula_approved",
        subject="phase:4",
        detail="fascia pediatrica",
    )]

    projected = project_session(decisions, linking, tmp_path / "evidence")

    assert projected == [{
        "schema_version": 1,
        "kind": "formula_proposal",
        "publication": "session_only",
        "concept": "fascia pediatrica",
        "columns": ["clinical.patient.birth_date"],
        "sql": "CASE WHEN age < 18 THEN 'pediatrica' ELSE 'adulta' END",
        "sources": ["Sintetizzata nella sessione"],
        "decision_seq": 9,
    }]