"""Scratch probe: recompute bucket tables from the adjudicated ledger under
proposed corrections and sensitivity scenarios. Reads the ledger read-only."""
import collections
import copy
import json
import sys

LEDGER = sys.argv[1]
M = ["gpt-5.6-sol", "gpt-6-sol", "gpt-6-astra", "gpt-6.1-sol", "claude-opus-5-5"]
SHORT = ["5.6 Sol", "6 Sol", "6 Astra", "6.1 Sol", "Opus 5.5"]


def load():
    return {x["id"]: x for x in json.load(open(LEDGER))}


def tables(d):
    det = collections.defaultdict(collections.Counter)
    fam = collections.defaultdict(collections.Counter)
    four = collections.defaultdict(collections.Counter)
    nfam = collections.Counter()
    for x in d.values():
        b = x["bucket"]
        nfam[b] += 1
        per = collections.Counter(r.split("--")[1] for r in set(x["asserted_runs"]))
        for m in M:
            if per[m]:
                det[b][m] += per[m]
                fam[b][m] += 1
                if per[m] == 4:
                    four[b][m] += 1
                if b == "B":
                    key = "B_runtime" if x["subtype"].startswith("runtime") else "B_support"
                    det[key][m] += per[m]
    return det, fam, four, nfam


def show(name, d):
    det, fam, four, nfam = tables(d)
    print(f"### {name}")
    print("families per bucket:", dict(nfam))
    for b in ["A", "B", "C", "D", "B_runtime", "B_support"]:
        print(f"{b:10s} det", [det[b][m] for m in M])
    for b in "ABCD":
        print(f"{b:10s} fam", [fam[b][m] for m in M], " 4/4", [four[b][m] for m in M])
    print("A+B det   ", [det["A"][m] + det["B"][m] for m in M])
    print("A+B fam   ", [fam["A"][m] + fam["B"][m] for m in M])
    print()


def run(case, model, rep):
    return f"{case}--{model}--r{rep}"


def corrections(d):
    d = copy.deepcopy(d)
    x = d["CA-ANSI-ONLY"]
    x["asserted_runs"].append(run("catch2-pr2849-ansi-column-wrap", "gpt-5.6-sol", 2))
    return d


def st_abi_b(d):
    d = copy.deepcopy(d)
    d["ST-ABI"]["bucket"] = "B"
    d["ST-ABI"]["subtype"] = "test/tooling/docs"
    return d


def posixspawn_b(d):
    d = copy.deepcopy(d)
    d["ST-POSIXSPAWN"]["bucket"] = "B"
    d["ST-POSIXSPAWN"]["subtype"] = "test/tooling/docs"
    return d


def posixspawn_merge(d):
    d = copy.deepcopy(d)
    runs = set(d["ST-VFORK-COVERAGE"]["asserted_runs"]) | set(d["ST-POSIXSPAWN"]["asserted_runs"])
    d["ST-VFORK-COVERAGE"]["asserted_runs"] = sorted(runs)
    del d["ST-POSIXSPAWN"]
    return d


def move(d, fid, bucket, subtype=""):
    d = copy.deepcopy(d)
    d[fid]["bucket"] = bucket
    d[fid]["subtype"] = subtype
    return d


base = load()
show("S0 published baseline", base)
s1 = corrections(base)
show("S1 attribution correction only (CA-ANSI-ONLY + 5.6 r2)", s1)
s2 = posixspawn_b(st_abi_b(s1))
show("S2 = S1 + ST-ABI->B + ST-POSIXSPAWN->B (separate family)", s2)
s2m = posixspawn_merge(st_abi_b(s1))
show("S2m = S1 + ST-ABI->B + ST-POSIXSPAWN merged into ST-VFORK-COVERAGE", s2m)

print("### A-bucket sensitivities (applied to S1; A detections only)")
for label, fid, nb, st in [
    ("ST-PROBE -> B", "ST-PROBE", "B", "test/tooling/docs"),
    ("RA-MACRO -> B", "RA-MACRO", "B", "runtime/UI/resource"),
    ("DJ-PARTITION -> B", "DJ-PARTITION", "B", "runtime/UI/resource"),
    ("SH-INIT -> A", "SH-INIT", "A", ""),
    ("SA-KDF-COST -> A", "SA-KDF-COST", "A", ""),
]:
    det, *_ = tables(move(s1, fid, nb, st))
    print(f"{label:22s} A", [det["A"][m] for m in M], " B", [det["B"][m] for m in M])
det, *_ = tables(move(move(s1, "ST-PROBE", "B", "test/tooling/docs"), "RA-MACRO", "B", "runtime/UI/resource"))
print(f"{'ST-PROBE+RA-MACRO -> B':22s} A", [det["A"][m] for m in M])
print()
print("### B-bucket sensitivities (applied to S2)")
for label, fid, nb, st in [
    ("SH-INIT -> B", "SH-INIT", "B", "runtime/UI/resource"),
    ("SA-TEST-COST -> C", "SA-TEST-COST", "C", ""),
    ("CA-QUADRATIC -> C", "CA-QUADRATIC", "C", ""),
    ("FE-FALLBACK -> B", "FE-FALLBACK", "B", "runtime/UI/resource"),
]:
    det, *_ = tables(move(s2, fid, nb, st))
    print(f"{label:22s} B", [det["B"][m] for m in M], " B_rt", [det["B_runtime"][m] for m in M])