#!/usr/bin/env python3
"""E124.1 offline verifier — stdlib only, imports no CAIN code.

Recomputes the headline numbers from the raw copies, checks the manifest, and fails closed.
Usage: python3 verify_e124_1_offline.py .
"""
import hashlib, json, sys
from pathlib import Path

root = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
raw = root / "raw"
fails = []
def check(name, ok, detail=""):
    print(("PASS " if ok else "FAIL ") + name + ((" :: " + detail) if detail else ""))
    if not ok: fails.append(name)

def sha(p):
    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()

ev = json.loads((root / "evidence.json").read_text())
man = json.loads((root / "manifest.json").read_text())

# 1 manifest integrity
bad = [f for f, h in man["files"].items() if not (root / f).exists() or sha(root / f) != h]
check("manifest hashes", not bad, ",".join(bad[:3]))

# 2 recompute resolved + evaluated from raw reports
resolved, evaluated = set(), set()
for rep in sorted(raw.glob("cain-anthropic-e124.*.json")):
    d = json.loads(rep.read_text())
    resolved |= set(d.get("resolved_ids") or [])
    rid = rep.name[len("cain-anthropic-e124."):-len(".json")]
    bf = raw / ("abatch_" + rid + ".jsonl")
    if bf.exists():
        for line in bf.read_text().splitlines():
            if line.strip():
                evaluated.add(json.loads(line)["instance_id"])
check("resolved count", len(resolved) == ev["swebench"]["resolved"], str(len(resolved)))
check("evaluated count", len(evaluated) == ev["swebench"]["evaluated"], str(len(evaluated)))
check("denominator 500", ev["swebench"]["denominator"] == 500)
check("resolved <= evaluated", len(resolved) <= len(evaluated))

# 3 preregistration integrity
pre = raw / "campaign21_preregistration.json"
check("preregistration hash", pre.exists() and sha(pre) == ev["campaign21"]["preregistration_sha256"])

# 4 campaign predictions consistency
pf = raw / "preds_campaign21.jsonl"
if pf.exists():
    rows = [json.loads(l) for l in pf.read_text().splitlines() if l.strip()]
    check("campaign prediction count", len(rows) == ev["campaign21"]["n_predictions"])
    check("campaign patched count",
          sum(1 for r in rows if (r.get("model_patch") or "").strip()) == ev["campaign21"]["n_with_patch"])
else:
    check("campaign predictions present", False)

# 5 research gates recomputed from raw copies
tr = json.loads((raw / "transfer.json").read_text())
check("transfer positive <= pathways", tr["n_positive"] <= tr["n_pathways"])
check("harmful rejected == n", tr["harmful"]["rejected"] == tr["harmful"]["n"])
si = json.loads((raw / "self_improvement.json").read_text())
check("no self-promotion", si.get("n_promoted") == 0)

# 6 replay claims
if (raw / "replay.json").exists():
    rp = json.loads((raw / "replay.json").read_text())
    check("replay record present", isinstance(rp.get("byte_identical"), dict) and len(rp["byte_identical"]) > 0)

# 7 mission honesty: a 12 h claim requires real elapsed seconds
m = ev["mission"]
if m.get("state") == "COMPLETED":
    check("12h mission elapsed >= 43200", (m.get("elapsed_s") or 0) >= 43200, str(m.get("elapsed_s")))
    check("12h mission journal verified", bool(m.get("journal_verified")))
else:
    check("12h mission not claimed complete", m.get("state") != "COMPLETED" or (m.get("elapsed_s") or 0) >= 43200,
          str(m.get("state")))

# 7b mission journal: independent SHA-256 hash-chain recomputation
jf = raw / "mission_journal.jsonl"
if jf.exists():
    def sha_obj(o):
        return hashlib.sha256(json.dumps(o, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
    prev, n, breaks = "0" * 64, 0, 0
    for line in jf.read_text().splitlines():
        if not line.strip():
            continue
        r = json.loads(line)
        body = {k: v for k, v in r.items() if k != "hash"}
        if r.get("prev") != prev or sha_obj(body) != r.get("hash"):
            breaks += 1
        prev, n = r["hash"], n + 1
    check("mission journal chain", breaks == 0, "%d breaks in %d records" % (breaks, n))
    sf = raw / "mission_status.json"
    if sf.exists():
        st = json.loads(sf.read_text())
        if st.get("state") == "COMPLETED":
            check("mission head hash matches status", prev == st.get("head_hash"))
        check("mission record count matches status", n == (st.get("cycles") or n))

# 7c neural adapter hash (proves the published adapter is the one measured)
ap = raw / "lora_adapter.pt"
if ap.exists():
    nr = json.loads((raw / "neural_results.json").read_text())
    check("LoRA adapter hash", sha(ap) == nr.get("adapter_sha256"))

# 7d E125-A recomputation from per-instance rows (the negative result must reproduce)
rf = raw / "e125a_rows.jsonl"
if rf.exists():
    rows = [json.loads(l) for l in rf.read_text().splitlines() if l.strip()]
    n = len(rows)
    fa = sum(1 for r in rows if r["full"]) / n
    ca = sum(1 for r in rows if r["compute_matched"]) / n
    b = sum(1 for r in rows if r["full"] and not r["compute_matched"])
    c = sum(1 for r in rows if r["compute_matched"] and not r["full"])
    e = ev["e125a"]
    check("E125-A full accuracy recomputes", abs(fa - e["full_accuracy"]) < 1e-9, "%.4f" % fa)
    check("E125-A control accuracy recomputes", abs(ca - e["compute_matched_accuracy"]) < 1e-9, "%.4f" % ca)
    check("E125-A McNemar counts recompute", b == e["mcnemar"]["full_only_correct"] and c == e["mcnemar"]["control_only_correct"])
    check("E125-A verdict matches sign of delta", (e["delta"] <= 0) == (e["verdict"] == "NEGATIVE_REPLICATION"))

# 7e E125 pre-registration was frozen before generation
ep = raw / "e125_preregistration.json"
check("E125 preregistration present", ep.exists() and bool(ev["e125_increment"]["preregistration"].get("frozen_at")))

# 7f E127 recomputation from per-instance rows
rf7 = raw / "e127_rows.jsonl"
if rf7.exists():
    rows = [json.loads(l) for l in rf7.read_text().splitlines() if l.strip()]
    test = [r for r in rows if r["split"] == "sealed_test"]
    def a(arm, rs):
        return sum(1 for r in rs if r[arm]) / max(1, len(rs))
    e = ev["e127"]["sealed_test"]
    check("E127 sealed baseline recomputes", abs(a("baseline_current", test) - e["baseline_current"]) < 1e-9,
          "%.4f" % a("baseline_current", test))
    check("E127 sealed control recomputes", abs(a("compute_matched", test) - e["compute_matched"]) < 1e-9,
          "%.4f" % a("compute_matched", test))
    check("E127 sealed cv_filter recomputes", abs(a("cv_filter_full", test) - e["cv_filter_full"]) < 1e-9,
          "%.4f" % a("cv_filter_full", test))
    b = sum(1 for r in test if r["cv_filter_full"] and not r["baseline_current"])
    c = sum(1 for r in test if r["baseline_current"] and not r["cv_filter_full"])
    check("E127 McNemar counts recompute", b == e["cv_vs_baseline_mcnemar"]["cv_only"]
          and c == e["cv_vs_baseline_mcnemar"]["baseline_only"], "%d/%d" % (b, c))
    check("E127 verdict matches threshold", (e["cv_filter_full"] - e["baseline_current"] >= 0.05
          and e["cv_filter_full"] - e["compute_matched"] >= 0.05
          and e["cv_vs_baseline_mcnemar"]["p"] < 0.05) == (ev["e127"]["verdict"] == "POSITIVE_PROMOTABLE"))

# 7g E127-B recomputation (the compute-matched correction)
rf8 = raw / "e127b_rows.jsonl"
if rf8.exists():
    rows = [json.loads(l) for l in rf8.read_text().splitlines() if l.strip()]
    test = [r for r in rows if r["split"] == "sealed_test"]
    def a2(arm):
        return sum(1 for r in test if r[arm]) / max(1, len(test))
    e = ev["e127b"]["sealed_test"]
    check("E127-B cv recomputes", abs(a2("cv_filter_full") - e["cv_filter_full"]) < 1e-9, "%.4f" % a2("cv_filter_full"))
    check("E127-B cm_full recomputes", abs(a2("cm_full") - e["cm_full"]) < 1e-9, "%.4f" % a2("cm_full"))
    check("E127-B verdict matches threshold",
          (e["cv_filter_full"] - e["cm_full"] >= 0.05 and e["cv_vs_cm_full"]["p"] < 0.05)
          == (ev["e127b"]["verdict"] == "SELECTION_EFFECT_CONFIRMED"))

# 8 no AGI claim
check("AGI not claimed", ev.get("agi_status") == "NOT ACHIEVED")

print("\n%d checks failed" % len(fails))
sys.exit(1 if fails else 0)
