#!/usr/bin/env python3
"""E125 standalone offline verifier. Standard library only. Imports no CAIN code.

Usage: python3 verify_e125_offline.py [bundle_dir]
Default bundle_dir is the directory containing this script.

It checks the manifest hashes, then recomputes every headline number from the raw rows and fails
closed on a mismatch, a missing file, or a denominator change.
"""
from __future__ import annotations

import hashlib
import json
import math
import sys
from pathlib import Path

FAILS: list[str] = []
CHECKS = 0


def ok(cond: bool, name: str, detail: str = "") -> None:
    global CHECKS
    CHECKS += 1
    if cond:
        print(f"PASS {name} {detail}")
    else:
        print(f"FAIL {name} {detail}")
        FAILS.append(name)


def sha(p: Path) -> str:
    h = hashlib.sha256()
    with p.open("rb") as fh:
        for c in iter(lambda: fh.read(1 << 20), b""):
            h.update(c)
    return h.hexdigest()


def load(p: Path):
    return json.loads(p.read_text())


def rows(p: Path):
    return [json.loads(x) for x in p.read_text().splitlines() if x.strip()]


def canon(obj) -> str:
    return json.dumps(obj, sort_keys=True, separators=(",", ":"))


def mcnemar(a, b):
    a_only = sum(1 for x, y in zip(a, b) if x and not y)
    b_only = sum(1 for x, y in zip(a, b) if y and not x)
    n = a_only + b_only
    if n == 0:
        return 1.0
    probs = [math.comb(n, i) * 0.5 ** n for i in range(n + 1)]
    p_obs = probs[a_only]
    return min(1.0, sum(x for x in probs if x <= p_obs + 1e-15))


def main() -> int:
    root = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(__file__).resolve().parent
    print(f"E125 offline verifier root={root}")
    man = load(root / "MANIFEST.json")
    for entry in man["files"]:
        p = root / entry["path"]
        if not p.exists():
            ok(False, f"manifest:{entry['path']}", "MISSING")
            continue
        ok(sha(p) == entry["sha256"], f"manifest:{entry['path']}", "")

    ev = root / "evidence"
    ch_results = load(ev / "challenge_results.json")
    ch_rows = rows(ev / "challenge_rows.jsonl")
    ch_answers = load(ev / "challenge_answers.json")
    commitment = load(ev / "challenge_commitment.json")["commitment"]
    ok(hashlib.sha256(canon(ch_answers).encode()).hexdigest() == commitment,
       "challenge_commitment", commitment[:16])
    for arm, summary in ch_results["arms"].items():
        sub = [r for r in ch_rows if r["arm"] == arm]
        acc = round(sum(1 for r in sub if r["correct"]) / len(sub), 4)
        ok(acc == summary["accuracy"] and len(sub) == summary["n"],
           f"challenge:{arm}", f"{sum(1 for r in sub if r['correct'])}/{len(sub)}={acc}")
    ok(len([r for r in ch_rows if r["arm"] == "full"]) == 300, "challenge_denominator", "300 full rows")
    full_bc = [r["correct"] for r in ch_rows if r["arm"] == "full" and r["novelty"] in ("B", "C")]
    flat_bc = [r["correct"] for r in ch_rows if r["arm"] == "flat_cv" and r["novelty"] in ("B", "C")]
    p = mcnemar(full_bc, flat_bc)
    ok(round(sum(full_bc) / len(full_bc), 4) == ch_results["primary_hypothesis"]["full_accuracy_BC"],
       "challenge_primary_full", f"{sum(full_bc)}/{len(full_bc)}")
    ok(abs(p - ch_results["primary_hypothesis"]["comparisons"]["full_vs_flat_cv_BC"]["p_exact_two_sided"]) < 1e-12,
       "challenge_primary_p", f"{p:.6g}")

    cont = load(ev / "continual_results.json")
    cont_rows = rows(ev / "continual_rows.jsonl")
    for mode, s in cont["summary"].items():
        sub = [r for r in cont_rows if r["mode"] == mode]
        n = sum(r["n"] for r in sub)
        acc = round(sum(r["correct"] for r in sub) / n, 4)
        ok(acc == s["accuracy"] and n == s["n_instances"], f"continual:{mode}", f"{acc}")
    ret = cont["retention_rows"]
    for mode, s in cont["summary"].items():
        sub = [r for r in ret if r["mode"] == mode]
        acc = round(sum(r["correct"] for r in sub) / sum(r["n"] for r in sub), 4)
        ok(acc == s["retention"], f"continual_retention:{mode}", f"{acc}")

    causal = load(ev / "causal_results.json")
    for mode, s in causal["summary"].items():
        sub = [r for r in causal["rows"] if r["mode"] == mode]
        acc = round(sum(r["accuracy"] for r in sub) / len(sub), 4)
        ok(acc == s["accuracy"], f"causal:{mode}", f"{acc}")
    aa = [q["correct"] for r in causal["rows"] if r["mode"] == "active" for q in r["queries"]]
    bb = [q["correct"] for r in causal["rows"] if r["mode"] == "passive" for q in r["queries"]]
    ok(abs(mcnemar(aa, bb) - causal["paired"]["active_vs_passive"]["p_exact_two_sided"]) < 1e-12,
       "causal_active_vs_passive", f"{sum(aa)} vs {sum(bb)}")

    tr = load(ev / "transfer_results.json")
    pos = tr["positive_rows"]
    ok(round(sum(r["final_accuracy"] for r in pos) / len(pos), 4) == tr["positive"]["mean_final_accuracy"],
       "transfer_positive", f"{len(pos)} pathways")
    harm = tr["harmful_rows"]
    handled = sum(1 for r in harm if r["source_rejected"] or r["final_accuracy"] >= 0.75)
    ok(handled == tr["harmful"]["harmful_handled"], "transfer_harmful_handled", f"{handled}/{len(harm)}")

    coll = load(ev / "collective_results.json")
    for mode, s in coll["summary"].items():
        sub = [r for r in coll["rows"] if r["mode"] == mode]
        acc = round(sum(r["correct"] for r in sub) / len(sub), 4)
        ok(acc == s["accuracy"], f"collective:{mode}", f"{acc}")
    ok(round(sum(r["correct"] for r in coll["rows"] if r["mode"] == "dynamic") / 300, 4) ==
       coll["summary"]["dynamic"]["accuracy"], "collective_denominator", "300")

    si = load(ev / "self_improvement_results.json")
    ok(si["n_evaluated"] == sum(1 for r in si["rows"] if r["status"] != "REFUSED_PROTECTED_TARGET"),
       "self_improvement_evaluated", str(si["n_evaluated"]))
    ok(si["n_refused_protected"] == sum(1 for r in si["rows"] if r["status"] == "REFUSED_PROTECTED_TARGET"),
       "self_improvement_protected", str(si["n_refused_protected"]))
    ok(si["n_promoted"] == sum(1 for r in si["rows"] if r["promoted"]), "self_improvement_promoted",
       str(si["n_promoted"]))

    gov = load(ev / "governance_results.json")
    un = sum(1 for t in gov["tests"] if t["expect"] == "DENY" and t["ok"])
    post = sum(1 for t in gov["tests"] if t["test"] == "after_kill" and t["ok"])
    ok(un == gov["unauthorized_effects"] == 0, "governance_unauthorized", str(un))
    ok(post == gov["post_fence_effects"] == 0, "governance_post_fence", str(post))
    ok(gov["ledger_chain_valid"], "governance_ledger_chain", "")

    adapt = load(ev / "adaptation_results.json")
    lora = adapt.get("lora") or adapt
    ok(bool(lora.get("weights_changed")), "adaptation_weights_changed", "")
    ok(lora["arms"]["lora"]["accuracy"] > lora["arms"]["frozen"]["accuracy"], "adaptation_lora_gt_frozen",
       f"{lora['arms']['lora']['accuracy']} vs {lora['arms']['frozen']['accuracy']}")

    disc = load(ev / "discovery_results.json")
    ok(disc["summary"]["n_cycles"] == 5, "discovery_cycles", str(disc["summary"]["n_cycles"]))
    ok(disc["independent_replication_of_e125"]["reproduced"], "discovery_replication", "")

    mis = load(ev / "mission_results.json")
    mrows = rows(ev / "mission_journal.jsonl")
    prev = "0" * 64
    good = True
    for row in mrows:
        body = {k: v for k, v in row.items() if k not in ("hash", "sig")}
        if row.get("prev") != prev or row.get("hash") != hashlib.sha256(canon(body).encode()).hexdigest():
            good = False
            break
        prev = row["hash"]
    ok(good and len(mrows) == mis["tasks_completed"], "mission_journal", f"{len(mrows)} rows")
    ok(mis["repeated_work"] == 0, "mission_no_repeated_work", str(mis["repeated_work"]))

    # tamper self-test: a changed raw row must change the recomputed accuracy
    if ch_rows:
        copy = [dict(r) for r in ch_rows]
        copy[0]["correct"] = not copy[0]["correct"]
        acc2 = sum(1 for r in copy if r["arm"] == copy[0]["arm"] and r["correct"]) / sum(1 for r in copy if r["arm"] == copy[0]["arm"])
        ok(abs(acc2 - ch_results["arms"][copy[0]["arm"]]["accuracy"]) > 0,
           "tamper_detection", "a flipped row changes the recomputed accuracy")

    print(f"\n{CHECKS - len(FAILS)}/{CHECKS} checks passed; {len(FAILS)} failed")
    if FAILS:
        print("FAILURES:", FAILS)
        return 1
    return 0


if __name__ == "__main__":
    raise SystemExit(main())
