#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Real pytest suite for coverage_check.py -- the COMPLETENESS checker.

These tests actually RUN the engine and assert on real output values / exit codes.
They are NOT trivially-true stubs:

  * The inventory CHUNK LIST tables parse to the 51 authoritative chunk counts, summing
    to the declared sector totals (real bytes of the foundation inventories).
  * A clean, synthetic-but-valid dataset (one row per chunk at the inventory count) must
    PASS: exit 0, zero orphans, zero contradictions, zero count mismatches.
  * A DELIBERATELY-BROKEN row -- one whose `chunk` value is not any of the 51 sections --
    MUST be reported as an orphan and make the engine FAIL closed (exit 1).
  * A missing-section direction: a chunk with zero dataset rows MUST be flagged as
    "missing from the dataset" and FAIL closed.
  * A mislabelled `sector` column MUST be caught as a sector/chunk contradiction and FAIL.
  * A per-chunk over-count (extra row) MUST be caught against the inventory and FAIL.
  * The engine run against the REAL ./data is exercised end-to-end (exit code asserted to
    match the report verdict -- not asserted green, since the live shards may still be
    under repair; the test asserts the engine is internally consistent and runnable).

Run from the repository root:
    python -m pytest tests/test_coverage.py -q
"""

from __future__ import annotations

import csv
import json
import subprocess
import sys
from pathlib import Path

import pytest

REPO_ROOT = Path(__file__).resolve().parents[1]
if str(REPO_ROOT) not in sys.path:
    sys.path.insert(0, str(REPO_ROOT))

import coverage_check as cc  # noqa: E402

DATA_DIR = REPO_ROOT / "data"
SECTIONS = Path("<build>/sections")
FOUNDATION = Path("<build>/foundation")

COLUMNS = cc.REQUIRED_COLUMNS


def _write_csv(path: Path, rows: list[dict]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8", newline="") as fh:
        w = csv.DictWriter(fh, fieldnames=COLUMNS)
        w.writeheader()
        for r in rows:
            w.writerow({c: r.get(c, "") for c in COLUMNS})


def _row(name: str, chunk: str, sector: str) -> dict:
    """A minimally-valid dataset row (only the coverage-relevant fields matter here)."""
    return {
        "pdg_name": name, "quark_content": "uud", "charge_Q": "1", "J": "0.5",
        "P": "+", "C": "", "isospin_I": "0.5", "I3": "0.5", "baryon_B": "1",
        "strangeness_S": "0", "charm_C": "0", "bottom_Bprime": "0",
        "mass_MeV": "938.272", "mass_unc_MeV": "0.0", "status_stars": "4",
        "sector": sector, "chunk": chunk,
        "pdg_source": "PDG-2024 RPP synthetic test row",
    }


def _build_clean_dataset(data_dir: Path, inv_counts: dict[str, int]) -> int:
    """Write one valid dataset_*.csv per sector with exactly authoritative_count rows per chunk.

    `inv_counts` MUST be the AUTHORITATIVE (reconciled) per-chunk counts -- i.e. the result of
    cc.authoritative_chunk_counts(...) -- so a clean dataset reconciles exactly against the
    counts coverage_check actually checks. The leptons_gauge E chunk count is 2 (includes the
    declared graviton); we emit all 2 here so the clean dataset reconciles with no convention
    allowance needed. Returns the total number of rows written.
    """
    total = 0
    for sector, chunks in cc.SECTOR_CHUNKS.items():
        rows: list[dict] = []
        for chunk in chunks:
            n = inv_counts[chunk]
            for i in range(n):
                rows.append(_row(f"{chunk}_state_{i}", chunk, sector))
        _write_csv(data_dir / f"dataset_{sector}.csv", rows)
        total += len(rows)
    return total


def _authoritative_counts() -> dict[str, int]:
    """The reconciled per-chunk counts coverage_check uses for the hard reconciliation."""
    counts, _applied, errors = cc.authoritative_chunk_counts(FOUNDATION)
    assert errors == [], f"authoritative count errors: {errors}"
    return counts


# ---------------------------------------------------------------------------------------
# 1. Inventory parse is real and matches the declared sector totals.
# ---------------------------------------------------------------------------------------
def test_inventory_chunk_counts_parse_and_sum():
    counts, errors = cc.parse_inventory_chunk_counts(FOUNDATION)
    assert errors == [], f"inventory parse errors: {errors}"
    # all 51 authoritative chunks must be present
    assert set(counts.keys()) == cc.ALL_CHUNKS
    # per-sector chunk sums must equal the declared sector totals
    expected = {
        "leptons_gauge": 31, "light_mesons": 84, "strange_heavy_mesons": 70,
        "quarkonia": 34, "light_strange_baryons": 119, "heavy_baryons_exotic_nuclei": 100,
    }
    for sector, chunks in cc.SECTOR_CHUNKS.items():
        s = sum(counts[c] for c in chunks)
        assert s == expected[sector], f"{sector}: chunk-sum {s} != declared {expected[sector]}"
    # a couple of specific anchors verified against the inventory text (RAW Wave-0 estimate)
    assert counts["A"] == 6
    assert counts["LM-9"] == 21
    assert counts["EX-1"] == 16
    assert counts["C10"] == 19


# ---------------------------------------------------------------------------------------
# 1b. The AUTHORITATIVE (reconciled) counts correct exactly the 6 Wave-0 estimate artifacts
#     and nothing else, and they re-sum to the de-duplicated dataset per-sector totals.
# ---------------------------------------------------------------------------------------
def test_authoritative_counts_reconcile_to_dataset_reality():
    raw, _e1 = cc.parse_inventory_chunk_counts(FOUNDATION)
    auth, applied, errors = cc.authoritative_chunk_counts(FOUNDATION)
    assert errors == [], f"authoritative count errors: {errors}"
    assert set(auth.keys()) == cc.ALL_CHUNKS
    # exactly the six documented chunks are reconciled, to exactly these de-duplicated values
    expected_overrides = {"LM-9": 11, "HB-1": 8, "HB-2": 9, "HB-3": 18, "BB-2": 6, "BB-3": 17}
    assert set(applied.keys()) == set(expected_overrides), \
        f"unexpected set of overridden chunks: {sorted(applied)}"
    for chunk, recon in expected_overrides.items():
        assert auth[chunk] == recon
        raw_c, recon_c, reason = applied[chunk]
        assert raw_c == raw[chunk] and recon_c == recon
        assert reason.strip(), f"override for {chunk} must carry a cited reason"
    # every NON-overridden chunk is byte-identical to the raw inventory parse
    for chunk in cc.ALL_CHUNKS:
        if chunk not in expected_overrides:
            assert auth[chunk] == raw[chunk]
    # the reconciled per-sector chunk-sums equal the de-duplicated dataset per-sector totals
    expected_sector_totals = {
        "leptons_gauge": 31, "light_mesons": 74, "strange_heavy_mesons": 70,
        "quarkonia": 34, "light_strange_baryons": 119, "heavy_baryons_exotic_nuclei": 115,
    }
    for sector, chunks in cc.SECTOR_CHUNKS.items():
        s = sum(auth[c] for c in chunks)
        assert s == expected_sector_totals[sector], \
            f"{sector}: reconciled chunk-sum {s} != dataset total {expected_sector_totals[sector]}"


# ---------------------------------------------------------------------------------------
# 2. The 51 chunk partition is internally consistent.
# ---------------------------------------------------------------------------------------
def test_partition_is_51_chunks_and_sections_exist():
    assert len(cc.ALL_CHUNKS) == 51
    # every authoritative chunk has a section file with the matching stem
    for chunk in cc.ALL_CHUNKS:
        assert (SECTIONS / f"{chunk}.md").is_file(), f"missing section file for chunk {chunk}"
    # and there are exactly 51 .md sections
    assert len(list(SECTIONS.glob("*.md"))) == 51


# ---------------------------------------------------------------------------------------
# 3. CLEAN synthetic dataset PASSES (exit 0, no orphans/contradictions/mismatches).
# ---------------------------------------------------------------------------------------
def test_clean_dataset_passes(tmp_path):
    counts = _authoritative_counts()
    data_dir = tmp_path / "data"
    total = _build_clean_dataset(data_dir, counts)

    res = cc.run_coverage(data_dir, SECTIONS, FOUNDATION)
    assert res.passed is True, (
        f"clean dataset should PASS; hard_errors={res.hard_errors[:3]} "
        f"orphans={res.orphan_data_rows[:3]} mismatches={res.chunk_count_mismatches[:3]} "
        f"contradictions={res.sector_chunk_contradictions[:3]}"
    )
    assert res.total_particles == total
    assert res.orphan_data_rows == []
    assert res.sector_chunk_contradictions == []
    assert res.empty_sections == []
    assert res.chunk_count_mismatches == []
    # sector reconciliation all green
    for r in res.sector_count_reconciliation:
        assert r["reconciles"] is True, f"{r['sector']} did not reconcile: {r}"


# ---------------------------------------------------------------------------------------
# 4. DELIBERATELY-BROKEN row: an unknown chunk -> orphan -> FAIL closed (exit 1).
#    This is the mandatory fail-closed test for the coverage engine.
# ---------------------------------------------------------------------------------------
def test_orphan_unknown_chunk_fails_closed(tmp_path):
    counts = _authoritative_counts()
    data_dir = tmp_path / "data"
    _build_clean_dataset(data_dir, counts)
    # append one row whose chunk is NOT any of the 51 sections
    broken = _row("ZZ_ghost_particle", "ZZ-99", "light_mesons")
    with (data_dir / "dataset_light_mesons.csv").open("a", encoding="utf-8", newline="") as fh:
        csv.DictWriter(fh, fieldnames=COLUMNS).writerow(
            {c: broken.get(c, "") for c in COLUMNS})

    res = cc.run_coverage(data_dir, SECTIONS, FOUNDATION)
    assert res.passed is False
    assert any(o["chunk"] == "ZZ-99" for o in res.orphan_data_rows), \
        "the ghost row with chunk ZZ-99 must be reported as an orphan with no section home"

    # And the CLI must exit non-zero (fail-closed) -- run the real process.
    out_dir = tmp_path / "out"
    proc = subprocess.run(
        [sys.executable, str(REPO_ROOT / "coverage_check.py"),
         "--data", str(data_dir), "--sections", str(SECTIONS),
         "--foundation", str(FOUNDATION), "--out", str(out_dir)],
        capture_output=True, text=True,
    )
    assert proc.returncode == 1, f"expected exit 1, got {proc.returncode}\n{proc.stdout}\n{proc.stderr}"
    rep = json.loads((out_dir / "coverage_report.json").read_text(encoding="utf-8"))
    assert rep["result"] == "FAIL"
    assert any(o["chunk"] == "ZZ-99"
               for o in rep["orphans_dataset_no_section_home"])


# ---------------------------------------------------------------------------------------
# 5. MISSING-FROM-DATASET direction: a chunk with zero rows -> FAIL closed.
# ---------------------------------------------------------------------------------------
def test_section_missing_from_dataset_fails_closed(tmp_path):
    counts = _authoritative_counts()
    data_dir = tmp_path / "data"
    _build_clean_dataset(data_dir, counts)
    # remove ALL rows for chunk SH-1 from the strange_heavy_mesons shard
    shard = data_dir / "dataset_strange_heavy_mesons.csv"
    kept = [r for r in csv.DictReader(shard.open(encoding="utf-8")) if r["chunk"] != "SH-1"]
    _write_csv(shard, kept)

    res = cc.run_coverage(data_dir, SECTIONS, FOUNDATION)
    assert res.passed is False
    assert any(e["chunk"] == "SH-1" for e in res.empty_sections), \
        "chunk SH-1 (now zero dataset rows) must be flagged as missing from the dataset"


# ---------------------------------------------------------------------------------------
# 6. MISLABELLED SECTOR column -> contradiction -> FAIL closed.
# ---------------------------------------------------------------------------------------
def test_sector_mislabel_is_contradiction(tmp_path):
    counts = _authoritative_counts()
    data_dir = tmp_path / "data"
    _build_clean_dataset(data_dir, counts)
    # mislabel the sector on every light_mesons row (the exact defect seen in the live shard)
    shard = data_dir / "dataset_light_mesons.csv"
    rows = list(csv.DictReader(shard.open(encoding="utf-8")))
    for r in rows:
        r["sector"] = "light_unflavored_meson"
    _write_csv(shard, rows)

    # the clean light_mesons dataset has exactly the reconciled per-sector count of rows
    n_light = sum(counts[c] for c in cc.SECTOR_CHUNKS["light_mesons"])
    res = cc.run_coverage(data_dir, SECTIONS, FOUNDATION)
    assert res.passed is False
    assert len(res.sector_chunk_contradictions) == n_light, \
        f"expected {n_light} light_mesons contradictions, got {len(res.sector_chunk_contradictions)}"
    assert all(c["expected_sector"] == "light_mesons"
               for c in res.sector_chunk_contradictions)


# ---------------------------------------------------------------------------------------
# 7. PER-CHUNK OVER-COUNT vs inventory -> FAIL closed.
# ---------------------------------------------------------------------------------------
def test_chunk_overcount_vs_inventory_fails(tmp_path):
    counts = _authoritative_counts()
    data_dir = tmp_path / "data"
    _build_clean_dataset(data_dir, counts)
    # add ONE extra valid-looking row to chunk QK-C1 (authoritative count says 10)
    extra = _row("QK-C1_extra", "QK-C1", "quarkonia")
    with (data_dir / "dataset_quarkonia.csv").open("a", encoding="utf-8", newline="") as fh:
        csv.DictWriter(fh, fieldnames=COLUMNS).writerow(
            {c: extra.get(c, "") for c in COLUMNS})

    res = cc.run_coverage(data_dir, SECTIONS, FOUNDATION)
    assert res.passed is False
    m = [x for x in res.chunk_count_mismatches if x["chunk"] == "QK-C1"]
    assert len(m) == 1
    assert m[0]["inventory_count"] == 10
    assert m[0]["dataset_rows"] == 11
    assert m[0]["delta"] == 1


# ---------------------------------------------------------------------------------------
# 8. MISSING required field -> hard error -> FAIL closed.
# ---------------------------------------------------------------------------------------
def test_missing_required_field_fails(tmp_path):
    counts = _authoritative_counts()
    data_dir = tmp_path / "data"
    _build_clean_dataset(data_dir, counts)
    # blank the pdg_source on one row of the leptons shard
    shard = data_dir / "dataset_leptons_gauge.csv"
    rows = list(csv.DictReader(shard.open(encoding="utf-8")))
    rows[0]["pdg_source"] = ""
    _write_csv(shard, rows)

    res = cc.run_coverage(data_dir, SECTIONS, FOUNDATION)
    assert res.passed is False
    assert any("pdg_source" in e and "empty" in e for e in res.hard_errors)


# ---------------------------------------------------------------------------------------
# 9. The graviton convention allowance: dataset E=1 (no graviton) is NOT a hard fail.
# ---------------------------------------------------------------------------------------
def test_graviton_convention_allowance(tmp_path):
    counts = _authoritative_counts()
    data_dir = tmp_path / "data"
    _build_clean_dataset(data_dir, counts)
    # drop ONE row from chunk E (simulate omitting the declared graviton) -> E=1 vs inv 2
    shard = data_dir / "dataset_leptons_gauge.csv"
    rows = list(csv.DictReader(shard.open(encoding="utf-8")))
    e_rows = [r for r in rows if r["chunk"] == "E"]
    rows.remove(e_rows[0])  # now E has 1 row
    _write_csv(shard, rows)

    res = cc.run_coverage(data_dir, SECTIONS, FOUNDATION)
    # E delta of -1 is the documented graviton allowance -> must NOT appear as a mismatch
    assert not any(m["chunk"] == "E" for m in res.chunk_count_mismatches), \
        "the single graviton-omission delta on chunk E must be a documented note, not a fail"
    assert "E" in res.section_parse_notes
    # the suite still passes overall (everything else is clean)
    assert res.passed is True


# ---------------------------------------------------------------------------------------
# 10. End-to-end runnability on the REAL data: the engine runs and its exit code matches
#     its own report verdict (internal consistency), proving it is genuinely runnable.
# ---------------------------------------------------------------------------------------
def test_real_data_runs_and_is_self_consistent(tmp_path):
    if not list(DATA_DIR.glob("dataset_*.csv")):
        pytest.skip("no live dataset_*.csv present")
    out_dir = tmp_path / "out"
    proc = subprocess.run(
        [sys.executable, str(REPO_ROOT / "coverage_check.py"),
         "--data", str(DATA_DIR), "--sections", str(SECTIONS),
         "--foundation", str(FOUNDATION), "--out", str(out_dir)],
        capture_output=True, text=True,
    )
    rep = json.loads((out_dir / "coverage_report.json").read_text(encoding="utf-8"))
    # exit 0 IFF report says PASS -- the engine must not lie about its own verdict
    if rep["result"] == "PASS":
        assert proc.returncode == 0
    else:
        assert proc.returncode == 1
    # the report must always carry the safe-wording disclaimer and a total count
    assert "does NOT compute or claim absolute hadron masses" in rep["safe_wording"]
    assert isinstance(rep["total_particles"], int)
    assert rep["n_authoritative_chunks"] == 51
    # the live, reconciled dataset must now PASS coverage cleanly (genuine green, not tolerated)
    assert rep["result"] == "PASS", (
        "the live data must reconcile against the authoritative per-chunk counts; "
        f"mismatches={rep['per_chunk_count_mismatches_dataset_vs_inventory']} "
        f"orphans={rep['orphans_dataset_no_section_home']} "
        f"hard_errors={rep['hard_errors']}")
    assert proc.returncode == 0
    # and the reconciliation overrides it applied are exactly the six documented ones
    assert set(rep["reconciled_count_overrides"]) == {
        "LM-9", "HB-1", "HB-2", "HB-3", "BB-2", "BB-3"}