#!/usr/bin/env python3
"""E108 offline verifier (stdlib only, imports no CAIN code).

Re-derives from rows.json: every success count, McNemar and sign test, the Holm decisions, practice
counts and oracle accuracy, and all twelve permutation gates (six practice sets x selection-aware and
E107 nulls) with an independent implementation (per-row feature indexing instead of a feature scan),
then checks every verdict in summary.json."""
import hashlib, json, math, random, sys
from pathlib import Path

C = []


def check(n, ok, d=""):
    C.append((n, bool(ok), str(d)))


def binom2(a, b):
    n = a + b
    return min(1.0, sum(math.comb(n, i) for i in range(min(a, b) + 1)) / 2 ** n * 2) if n else 1.0


def feats(size):
    f = [("col", k) for k in range(size)] + [("row", k) for k in range(size)]
    f += [("cell", (x, y)) for x in range(size) for y in range(size)]
    f += [("scol", d) for d in range(-size + 1, size)] + [("srow", d) for d in range(-size + 1, size)]
    f += [("bcol", d) for d in range(-size, 0)]
    return f


def member_index(F, size, start, bx):
    """cell -> indices of features containing it, for one row's frame."""
    pos = {f: i for i, f in enumerate(F)}
    out = {}
    for x in range(size):
        for y in range(size):
            idx = [pos[("col", x)], pos[("row", y)], pos[("cell", (x, y))]]
            if start is not None:
                idx += [pos[("scol", x - start[0])], pos[("srow", y - start[1])]]
            if bx is not None and x - bx < 0 and ("bcol", x - bx) in pos:
                idx.append(pos[("bcol", x - bx)])
            out[(x, y)] = sorted(idx)
    return out


def gate(rows, conditional, perms=999, seed=108, alpha=0.01):
    size = rows[0]["size"]; F = feats(size)
    R = []
    for r in rows:
        sup = [tuple(c) for c in r["support"]]
        eff = sup
        if conditional:
            pre = {tuple(c) for c in r["pre"]}
            eff = [c for c in sup if c not in pre]
            if tuple(r["cause"]) not in eff:
                eff = sup
        R.append((tuple(r["cause"]), eff, member_index(F, size, r["start"], r["barrier_x"])))
    E = [0.0] * len(F)
    for i in range(len(F)):
        for _, eff, mi in R:
            E[i] += sum(1 for c in eff if i in mi[c]) / len(eff)

    def stat(cells):
        cnt = [0] * len(F)
        for c, (_, _, mi) in zip(cells, R):
            for i in mi[c]:
                cnt[i] += 1
        best, arg = -1e9, None
        for i in range(len(F)):
            if E[i] < 1.0:
                continue
            z = (cnt[i] - E[i]) / E[i] ** 0.5
            if z > best:
                best, arg = z, i
        return best, arg
    obs, ai = stat([r[0] for r in R])
    rng = random.Random(seed)
    null = sorted(stat([rng.choice(r[1]) for r in R])[0] for _ in range(perms))
    p = (1 + sum(1 for v in null if v >= obs)) / (1 + len(null))
    k, v = F[ai]
    return round(obs, 3), [k, list(v) if k == "cell" else v], round(p, 4), p <= alpha


def main():
    root = Path(sys.argv[1] if len(sys.argv) > 1 else ".")
    for rel, h in json.loads((root / "MANIFEST.json").read_text())["files"].items():
        check(f"hash {rel}", hashlib.sha256((root / rel).read_bytes()).hexdigest() == h)
    raw = json.loads((root / "rows.json").read_text()); s = json.loads((root / "summary.json").read_text())
    T = s["tests"]; tests = [k[5:-8] for k in raw if k.startswith("test_") and k.endswith("_control")]
    for k in tests:
        a, b = raw[f"test_{k}_control"], raw[f"test_{k}_treatment"]; t = T[k]
        check(f"{k}: same incidents in both arms", [r["id"] for r in a] == [r["id"] for r in b])
        check(f"{k}: success recount", (sum(r["success"] for r in a), sum(r["success"] for r in b), len(a)) == (t["success_a"], t["success_b"], t["n"]))
        x = sum(1 for u, v in zip(a, b) if u["success"] and not v["success"]); y = sum(1 for u, v in zip(a, b) if v["success"] and not u["success"])
        check(f"{k}: McNemar recomputed", (x, y) == (t["mcnemar"]["a_only"], t["mcnemar"]["b_only"]) and abs(binom2(x, y) - t["mcnemar"]["p"]) < 1e-9)
        st = lambda r: r["steps"] if r["success"] else r["max_steps"]
        d = [st(v) - st(u) for u, v in zip(a, b)]
        pos, neg = sum(1 for q in d if q > 0), sum(1 for q in d if q < 0)
        check(f"{k}: step sign test recomputed", (pos, neg) == (t["steps_b_minus_a"]["pos"], t["steps_b_minus_a"]["neg"]) and abs(binom2(pos, neg) - t["steps_b_minus_a"]["p"]) < 1e-9)
    G = {}
    used_all = ok_all = 0
    for key in [k for k in raw if k.startswith("practice_")]:
        name = key[9:]; rows = raw[key]; ps = s[key]; u = [r for r in rows if r["used"]]
        check(f"practice {name}: counts", (len(rows), len(u)) == (ps["n"], ps["used"]))
        check(f"practice {name}: used rows exact + census complete", all(r["candidates"] and len(r["candidates"]) == 1 and r["census_complete"] and r["cause"] == r["candidates"][0] for r in u))
        okc = sum(bool(r["oracle_cause_ok"]) for r in u)
        check(f"practice {name}: oracle accuracy recount ({okc}/{len(u)})", okc == ps["oracle_cause_ok"])
        used_all += len(u); ok_all += okc
        for cond, field in ((True, "gate"), (False, "gate_e107_unconditional")):
            o, f, p, use = gate(u, cond)
            g = ps[field]; G[(name, cond)] = (use, f, p)
            check(f"practice {name}: {'selection-aware' if cond else 'E107'} gate re-derived (z {o}, {f}, p {p}, usable {use})",
                  (o, f, p, use) == (g["observed_max_z"], g["feature"], g["p_value"], g["usable"]))
    v = T["verdicts"]
    TRUE = {"edge": ["col", 0], "row0": ["row", 0], "start_row": ["srow", 0], "barrier_adj": ["bcol", -1]}
    rules = ["edge", "row0", "start_row", "barrier_adj"]
    check("H1 verdict", v["H1_calibration"] == all(not G[(k, True)][0] for k in ("grid_kd", "svc_uniform")))
    check("H2 verdicts", v["H2_detection"] == {k: G[(k, True)][0] and G[(k, True)][1] == TRUE[k] for k in rules})
    ps_ = [T[k]["mcnemar"]["p"] for k in rules]
    order = sorted(range(4), key=lambda i: ps_[i]); rej = [False] * 4
    for rank, i in enumerate(order):
        if ps_[i] <= 0.05 / (4 - rank):
            rej[i] = True
        else:
            break
    check("H3 verdicts (Holm re-derived)", v["H3_use"] == {k: bool(r and T[k]["mcnemar"]["b_only"] > T[k]["mcnemar"]["a_only"]) for k, r in zip(rules, rej)})
    loss = lambda t: t["mcnemar"]["p"] < 0.05 and t["mcnemar"]["a_only"] > t["mcnemar"]["b_only"]
    check("H4 verdict", v["H4_no_harm"] == (not loss(T["svc_uniform"]) and not loss(T["grid_kd"])))
    check("H5 verdict", v["H5_attribution"] == round(ok_all / used_all, 4) and v["H5_pass"] == (ok_all / used_all >= 0.95))
    passed = sum(ok for _, ok, _ in C)
    for n, ok, d in C:
        print(("PASS " if ok else "FAIL ") + n + ("" if ok else f" :: {d}"))
    print(f"\n{passed}/{len(C)} checks passed")
    return 0 if passed == len(C) else 1


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