#!/usr/bin/env python3
"""E110 G6 transfer verifier (stdlib only; imports no CAIN code).

Re-derives from rows.json (+ the included E108 rows, pinned by SHA-256): the source laws (independent permutation-gate
implementation shared with the E108 verifier), every arm's success count, each replicate's verified-transfer exact test
recomputed from its 3 target experiments, McNemar C vs A, the Holm decisions and block condition, D_k experiments saved,
and the negative-transfer verdicts."""
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 mcn(a, b):
    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"])
    return x, y, binom2(x, y)


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 inside_f(f, c, start, bx):
    k, v = f; x, y = c
    return {"col": x == v, "row": y == v, "cell": (x, y) == tuple(v) if k == "cell" else False,
            "scol": start is not None and x - start[0] == v, "srow": start is not None and y - start[1] == v,
            "bcol": bx is not None and x - bx == v}[k]


def exact(feature, rows):
    f = (feature[0], tuple(feature[1]) if feature[0] == "cell" else feature[1]); p, hits = 1.0, 0
    for r in rows:
        pre = {tuple(c) for c in r["pre"]}
        sup = [tuple(c) for c in r["support"] if tuple(c) not in pre] or [tuple(c) for c in r["support"]]
        frac = sum(1 for c in sup if inside_f(f, c, r["start"], r["barrier_x"])) / len(sup)
        if inside_f(f, tuple(r["cause"]), r["start"], r["barrier_x"]):
            hits += 1; p *= frac
        else:
            p = 1.0; break
    return bool(rows) and hits == len(rows) and p <= 0.05


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)
    s = json.loads((root / "summary.json").read_text()); raw = json.loads((root / "rows.json").read_text())
    e108p = root / "e108_rows.json"
    check("included E108 rows match the pinned SHA-256", hashlib.sha256(e108p.read_bytes()).hexdigest() == s["e108_rows_sha256"])
    e108 = json.loads(e108p.read_text())
    srcs = {f"svc:{k}": [r for r in e108[f"practice_{k}"] if r["used"]] for k in ("barrier_adj", "start_row", "row0", "edge")}
    srcs["grid:barrier_adj"] = [r for r in raw["source_grid_barrier_adj"] if r["used"]]
    for name, rows in srcs.items():
        o, f, p, use = gate(rows, True)
        g = s["sources"][name]["gate"]
        check(f"source law {name} re-derived ({f}, p {p})", (o, f, p, use) == (g["observed_max_z"], g["feature"], g["p_value"], g["usable"]))
    R, K, PER = 5, 3, 20
    holm_in = []
    for cid, c in s["conditions"].items():
        arms = {a: raw[f"{cid}_{a}"] for a in "ABCD"}
        check(f"{cid}: same incidents in every arm", len({tuple(r["id"] for r in v) for v in arms.values()}) == 1)
        check(f"{cid}: success recount", {a: sum(r["success"] for r in v) for a, v in arms.items()} == c["success"])
        used = [r for r in raw[f"{cid}_practice"] if r["used"]]
        sets = [used[i * K:(i + 1) * K] for i in range(R)]
        acc = [exact(c["source_feature"], st) for st in sets]
        check(f"{cid}: verified-transfer test recomputed from the target experiments ({sum(acc)}/5 accepted)", sum(acc) == c["C_accepted_replicates"])
        x, y, p = mcn(arms["A"], arms["C"])
        check(f"{cid}: McNemar C vs A recomputed ({y} won, {x} lost)", (x, y) == (c["C_vs_A"]["mcnemar"]["a_only"], c["C_vs_A"]["mcnemar"]["b_only"]) and abs(p - c["C_vs_A"]["mcnemar"]["p"]) < 1e-9)
        blocks = sum(sum(r["success"] for r in arms["C"][i * PER:(i + 1) * PER]) >= sum(r["success"] for r in arms["A"][i * PER:(i + 1) * PER]) for i in range(R))
        check(f"{cid}: block condition recount ({blocks}/5)", blocks == c["C_ge_A_blocks"])
        saved = "> 17"
        for k in (3, 6, 10, 15, 20):
            key = f"{cid}_Dk{k}"
            if key in raw:
                a2, b2, p2 = mcn(raw[key], arms["C"])
                if not (p2 < 0.05 and b2 > a2):
                    saved = k - K; break
        check(f"{cid}: experiments saved recomputed ({saved})", saved == c["experiments_saved"])
        if cid.startswith("P"):
            holm_in.append((cid, p, y > x, blocks))
    ps = [h[1] for h in holm_in]; order = sorted(range(len(ps)), key=lambda i: ps[i]); rej = [False] * len(ps)
    for rank, i in enumerate(order):
        if ps[i] <= 0.05 / (len(ps) - rank): rej[i] = True
        else: break
    sig = {h[0]: bool(r and h[2] and h[3] >= 4) for h, r in zip(holm_in, rej)}
    v = s["verdicts"]
    check(f"G6 per-pathway verdicts re-derived (Holm + blocks): {sum(sig.values())}/5", sig == v["G6_primary_per_pathway"])
    check("G6 primary verdict (>= 3 of 5)", v["G6_primary"] == (sum(sig.values()) >= 3))
    for n in ("N1", "N2"):
        c = s["conditions"][n]; x, y, p = mcn(raw[f"{n}_A"], raw[f"{n}_C"])
        ok = c["C_accepted_replicates"] <= 1 and not (x > y and p / 2 < 0.05)
        check(f"{n}: negative-transfer verdict re-derived (C accepted {c['C_accepted_replicates']}/5, C {c['success']['C']} vs A {c['success']['A']}, blind B {c['success']['B']})", ok == v["NEG1"][n])
    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())
