"""Load every sweep, fit the scalings the theorems predict, emit figures + summary."""

import json
import os
import sys

import numpy as np

HERE = os.path.dirname(os.path.abspath(__file__))
RES = os.path.join(HERE, "results")
FIG = os.path.join(HERE, "figs")
os.makedirs(FIG, exist_ok=True)


def load(name):
    p = os.path.join(RES, name)
    if not os.path.exists(p):
        return []
    with open(p) as f:
        return json.load(f)


def agg(recs, key, value_fn):
    """group by key -> (xs, mean, sem)"""
    d = {}
    for r in recs:
        d.setdefault(r[key], []).append(value_fn(r))
    xs = sorted(d)
    mu = np.array([np.mean(d[x]) for x in xs])
    se = np.array([np.std(d[x]) / max(1, np.sqrt(len(d[x]))) for x in xs])
    return np.array(xs, float), mu, se


def loglog_slope(x, y):
    ok = (x > 0) & (y > 0) & np.isfinite(y)
    if ok.sum() < 2:
        return float("nan"), float("nan")
    p, cov = np.polyfit(np.log(x[ok]), np.log(y[ok]), 1, cov=True)
    return float(p[0]), float(np.sqrt(cov[0, 0]))


def r2(x, y, slope, inter):
    pred = slope * x + inter
    ss = np.sum((y - pred) ** 2)
    tot = np.sum((y - y.mean()) ** 2)
    return float(1 - ss / tot) if tot > 0 else float("nan")


summary = {}

# =====================================================================
# Claim 1 -- mechanism audit (exp2)
# =====================================================================
e2 = load("exp2_mechanism.json")
if e2:
    S = {}
    for tag in ["m", "n", "T", "d", "K", "overlap"]:
        S[tag] = [r for r in e2 if r["sweep"] == tag]

    out = {}
    # (A) the linearisation identity: |measured - first_order| ~ m^{-1/2}
    ms, rem, rse = agg(S["m"], "m", lambda r: abs(r["remainder"]))
    _, remM, _ = agg(S["m"], "m", lambda r: abs(r["remainder_M"]))
    _, fo_m, _ = agg(S["m"], "m", lambda r: abs(r["first_order"]))
    sl, sle = loglog_slope(ms, rem)
    slM, slMe = loglog_slope(ms, remM)
    out["remainder_vs_m"] = dict(
        m=ms.tolist(), remainder=rem.tolist(), sem=rse.tolist(),
        remainder_M=remM.tolist(), first_order=fo_m.tolist(),
        slope=sl, slope_err=sle, slope_M=slM, slope_M_err=slMe,
        predicted_slope=-0.5)

    # (B) remainder vs eta*T -> Thm-1 third term says (eta T)^2
    Ts, remT, _ = agg(S["T"], "T", lambda r: abs(r["remainder"]))
    slT, slTe = loglog_slope(Ts, remT)
    _, foT, _ = agg(S["T"], "T", lambda r: abs(r["first_order"]))
    slFO, slFOe = loglog_slope(Ts, foT)
    _, measT, _ = agg(S["T"], "T", lambda r: abs(r["measured"]))
    out["vs_T"] = dict(T=Ts.tolist(), remainder=remT.tolist(),
                       first_order=foT.tolist(), measured=measT.tolist(),
                       slope_remainder=slT, slope_remainder_err=slTe,
                       slope_first_order=slFO, slope_first_order_err=slFOe,
                       predicted_remainder_slope=2.0,
                       predicted_first_order_slope=1.0)

    # (C) sampling term vs n -> n^{-1/2}
    ns, fl, fse = agg(S["n"], "n", lambda r: abs(r["fo_fluct"]))
    _, fm, _ = agg(S["n"], "n", lambda r: abs(r["fo_mean"]))
    _, mm_, _ = agg(S["n"], "n", lambda r: abs(r["measured"]))
    sln, slne = loglog_slope(ns, fl)
    slnm, _ = loglog_slope(ns, fm)
    out["vs_n"] = dict(n=ns.tolist(), fo_fluct=fl.tolist(), sem=fse.tolist(),
                       fo_mean=fm.tolist(), measured=mm_.tolist(),
                       slope_fluct=sln, slope_fluct_err=slne,
                       slope_mean=slnm, predicted_fluct_slope=-0.5,
                       predicted_mean_slope=0.0)

    # (D) sampling term vs d -> d^{-1}
    ds, fld, _ = agg(S["d"], "d", lambda r: abs(r["fo_fluct"]))
    _, fmd, _ = agg(S["d"], "d", lambda r: abs(r["fo_mean"]))
    sld, slde = loglog_slope(ds, fld)
    sldm, sldme = loglog_slope(ds, fmd)
    out["vs_d"] = dict(d=ds.tolist(), fo_fluct=fld.tolist(), fo_mean=fmd.tolist(),
                       slope_fluct=sld, slope_fluct_err=slde,
                       slope_mean=sldm, slope_mean_err=sldme,
                       predicted_fluct_slope=-1.0, predicted_mean_slope=-2.0)

    # (E) sqrt(K-k) dependence, from the per-task forgetting inside K=12 runs
    kk = {}
    for r in S["K"]:
        Kt = r["K"]
        for k, v in enumerate(r["fo_per_k"]):
            if Kt - 1 - k > 0:
                kk.setdefault(Kt - 1 - k, []).append(abs(v))
    xs = np.array(sorted(kk), float)
    ys = np.array([np.mean(kk[int(x)]) for x in xs])
    ses = np.array([np.std(kk[int(x)]) / np.sqrt(len(kk[int(x)])) for x in xs])
    slk, slke = loglog_slope(xs, ys)
    out["vs_Kk"] = dict(Kk=xs.tolist(), forget=ys.tolist(), sem=ses.tolist(),
                        slope=slk, slope_err=slke, predicted_slope=0.5)

    # (F) control: break orthogonality of task means
    ov, ovy, ovse = agg(S["overlap"], "overlap", lambda r: abs(r["measured"]))
    out["overlap_control"] = dict(overlap=ov.tolist(), forget=ovy.tolist(),
                                  sem=ovse.tolist())
    summary["claim1"] = out

# =====================================================================
# Claim 1/6 -- full GD sweeps (exp1)
# =====================================================================
e1 = load("exp1_scalings.json")
if e1:
    out = {}
    for tag, key in [("n", "n"), ("m", "m"), ("etaT", "T"), ("eta", "eta")]:
        rs = [r for r in e1 if r["sweep"] == tag]
        if not rs:
            continue
        xs, mu, se = agg(rs, key, lambda r: abs(r["forget"][0]))
        _, tf, tse = agg(rs, key, lambda r: abs(r["test_forget"][0]))
        _, gg, _ = agg(rs, key, lambda r: r["gen_gap"][0])
        sl, sle = loglog_slope(xs, mu)
        out[tag] = dict(x=xs.tolist(), train_forget=mu.tolist(), sem=se.tolist(),
                        test_forget=tf.tolist(), test_sem=tse.tolist(),
                        gen_gap=gg.tolist(), slope=sl, slope_err=sle)
    rs = [r for r in e1 if r["sweep"] == "Kk"]
    if rs:
        kk = {}
        for r in rs:
            K = r["K"]
            for k, v in enumerate(r["forget"][:-1]):
                kk.setdefault(K - 1 - k, []).append(abs(v))
        xs = np.array(sorted(kk), float)
        ys = np.array([np.mean(kk[int(x)]) for x in xs])
        ses = np.array([np.std(kk[int(x)]) / np.sqrt(len(kk[int(x)])) for x in xs])
        sl, sle = loglog_slope(xs, ys)
        out["Kk"] = dict(x=xs.tolist(), train_forget=ys.tolist(),
                         sem=ses.tolist(), slope=sl, slope_err=sle)
    summary["claim1_gd"] = out

# =====================================================================
# Claim 2 -- parameter regime (exp3 "regime")
# =====================================================================
e3 = load("exp3_regime.json")
if e3:
    out = {}
    for var in ["prescribed", "fixed_n", "long_train", "small_m"]:
        rs = [r for r in e3 if r.get("variant") == var]
        if not rs:
            continue
        xs, mu, se = agg(rs, "d", lambda r: abs(r["measured"]))
        sl, sle = loglog_slope(xs, mu)
        out[var] = dict(d=xs.tolist(), forget=mu.tolist(), sem=se.tolist(),
                        slope=sl, slope_err=sle,
                        n=[[r["n"] for r in rs if r["d"] == x][0] for x in xs],
                        T=[[r["T"] for r in rs if r["d"] == x][0] for x in xs],
                        m=[[r["m"] for r in rs if r["d"] == x][0] for x in xs])
    summary["claim2"] = out

    # Claim 3 -- uniform train error, hinge loss
    rs = [r for r in e3 if r["sweep"] == "claim3"]
    if rs:
        c3 = []
        # Group by eta as well as (n, m): the two horizons eta*T = 400 and 1600
        # give qualitatively different answers for the *loss* half of Theorem 2,
        # and averaging them together hides that.
        for key in sorted({(r["eta"], r["n"], r["m"]) for r in rs}):
            g = [r for r in rs if (r["eta"], r["n"], r["m"]) == key]
            K = g[0]["K"]
            err_end = np.array([r["err_at"][K - 1] for r in g])
            terr_end = np.array([r["test_err_at"][K - 1] for r in g])
            loss_end = np.array([r["loss_at"][K - 1] for r in g])
            tloss_end = np.array([r["test_loss_at"][K - 1] for r in g])
            diag = np.array([[r["err_at"][k][k] for k in range(K)] for r in g])
            c3.append(dict(eta=key[0], n=key[1], m=key[2], K=K,
                           T=g[0]["T"], d=g[0]["d"],
                           etaT=float(key[0] * g[0]["T"]),
                           etaT_over_d2=float(key[0] * g[0]["T"] / g[0]["d"] ** 2),
                           test_loss_end=tloss_end.mean(0).tolist(),
                           test_loss_end_max=float(tloss_end.mean(0).max()),
                           train_err_end=err_end.mean(0).tolist(),
                           train_err_end_max=float(err_end.mean(0).max()),
                           train_err_own=diag.mean(0).tolist(),
                           test_err_end=terr_end.mean(0).tolist(),
                           test_err_end_max=float(terr_end.mean(0).max()),
                           train_loss_end=loss_end.mean(0).tolist(),
                           train_loss_end_max=float(loss_end.mean(0).max()),
                           seeds=len(g)))
        summary["claim3"] = c3

    # Claim 6 -- (n, m) joint grid
    rs = [r for r in e3 if r["sweep"] == "claim6"]
    if rs:
        nn = sorted({r["n"] for r in rs})
        mm = sorted({r["m"] for r in rs})
        grid_tr = np.zeros((len(nn), len(mm)))
        grid_ts = np.zeros((len(nn), len(mm)))
        grid_gg = np.zeros((len(nn), len(mm)))
        for i, n in enumerate(nn):
            for j, m in enumerate(mm):
                g = [r for r in rs if r["n"] == n and r["m"] == m]
                grid_tr[i, j] = np.mean([abs(r["forget"][0]) for r in g])
                grid_ts[i, j] = np.mean([abs(r["test_forget"][0]) for r in g])
                grid_gg[i, j] = np.mean([r["gen_gap"][0] for r in g])
        # decomposition check: |F^ts| <= |F^tr| + |F^gen| per run
        viol, tot, ratios = 0, 0, []
        for r in rs:
            lhs = r["test_forget"][0]
            rhs = r["forget"][0] + r["gen_gap"][0]
            tot += 1
            if lhs > rhs + 1e-12:
                viol += 1
            ratios.append(lhs - rhs)
        # The *shape* of the grid is the claim, and the cleanest read of it is
        # the marginal slope along each axis holding the other fixed: an
        # additive bound predicts that moving along an axis whose term is not
        # dominant produces a flat (plateaued) slope.
        marg = dict(vs_n=[], vs_m=[])
        for j, m in enumerate(mm):
            sl, se = loglog_slope(np.array(nn, float), grid_tr[:, j])
            marg["vs_n"].append(dict(m=m, slope=sl, slope_err=se))
        for i, n in enumerate(nn):
            sl, se = loglog_slope(np.array(mm, float), grid_tr[i, :])
            marg["vs_m"].append(dict(n=n, slope=sl, slope_err=se))
        summary["claim6"] = dict(
            n=nn, m=mm, train_forget=grid_tr.tolist(),
            test_forget=grid_ts.tolist(), gen_gap=grid_gg.tolist(),
            marginal_slopes=marg,
            decomp_runs=tot, decomp_violations=viol,
            decomp_slack_mean=float(np.mean(ratios)),
            decomp_slack_min=float(np.min(ratios)))

# =====================================================================
# Claims 4 & 5 -- generalization gap (exp4)
# =====================================================================
e4 = load("exp4_gengap.json")
if e4:
    out = {}
    for tag, key in [("n", "n"), ("T", "T"), ("m", "m"), ("K", "K")]:
        rs = [r for r in e4 if r["sweep"] == tag]
        if not rs:
            continue
        xs, mu, se = agg(rs, key, lambda r: r["gen_gap"])
        _, b3, _ = agg(rs, key, lambda r: r["rhs_thm3"])
        _, b4, _ = agg(rs, key, lambda r: r["rhs_thm4"])
        _, b3c, _ = agg(rs, key, lambda r: r["rhs_thm3_core"])
        _, b4c, _ = agg(rs, key, lambda r: r["rhs_thm4_core"])
        _, ex3, _ = agg(rs, key, lambda r: r["exponent_thm3"])
        _, ex4, _ = agg(rs, key, lambda r: r["exponent_thm4"])
        _, cum, _ = agg(rs, key, lambda r: r["cum_train_loss"][0])
        _, ck, _ = agg(rs, key, lambda r: r["c_kK"])
        _, tf, _ = agg(rs, key, lambda r: r["train_forget"])
        sl, sle = loglog_slope(xs, np.abs(mu))
        s3, _ = loglog_slope(xs, b3)
        s4, _ = loglog_slope(xs, b4)
        scum, _ = loglog_slope(xs, cum)
        out[tag] = dict(x=xs.tolist(), gap=mu.tolist(), sem=se.tolist(),
                        rhs_thm3=b3.tolist(), rhs_thm4=b4.tolist(),
                        rhs_thm3_core=b3c.tolist(), rhs_thm4_core=b4c.tolist(),
                        exponent_thm3=ex3.tolist(), exponent_thm4=ex4.tolist(),
                        slope_thm3_core=loglog_slope(xs, b3c)[0],
                        slope_thm4_core=loglog_slope(xs, b4c)[0],
                        cum_train_loss=cum.tolist(), c_kK=ck.tolist(),
                        train_forget=tf.tolist(),
                        slope_gap=sl, slope_gap_err=sle,
                        slope_thm3=s3, slope_thm4=s4, slope_cum=scum,
                        seeds=len({r["seed"] for r in rs}))
    # constants that make each bound tight at the base point, and validity
    for tag in out:
        g = np.abs(np.array(out[tag]["gap"]))
        b3 = np.array(out[tag]["rhs_thm3"])
        b4 = np.array(out[tag]["rhs_thm4"])
        b3c = np.array(out[tag]["rhs_thm3_core"])
        b4c = np.array(out[tag]["rhs_thm4_core"])
        out[tag]["c3"] = float(np.max(g / b3c))
        out[tag]["c4"] = float(np.max(g / b4c))
        out[tag]["ratio_thm3_core"] = (g / b3c).tolist()
        out[tag]["ratio_thm4_core"] = (g / b4c).tolist()
    summary["claim45"] = out

# =====================================================================
# Claim 2 (internal consistency) -- how large must eta*T actually be? (exp5)
#
# Thm 1/2 ask for eta*T = Theta(d^2) *and* m = Omega~(d^8 K^4) at the same
# time.  Those are only mutually satisfiable if the eta*T needed to fit a task
# does not grow with m.  Fit  log etaT_needed = const + alpha log d + beta log m
# and report both exponents: the regime is self-consistent iff beta ~ 0.
# =====================================================================
e5 = load("exp5_etaT.json")
if e5:
    ok = [r for r in e5 if r.get("etaT_needed")]
    censored = [r for r in e5 if not r.get("etaT_needed")]
    out = dict(n_probes=len(e5), n_resolved=len(ok), n_censored=len(censored),
               T_fixed=(e5[0]["T"] if e5 else None))
    if len(ok) >= 4:
        A = np.array([[1.0, np.log(r["d"]), np.log(r["m"])] for r in ok])
        b = np.log(np.array([r["etaT_needed"] for r in ok]))
        coef, *_ = np.linalg.lstsq(A, b, rcond=None)
        pred = A @ coef
        ss, tot = np.sum((b - pred) ** 2), np.sum((b - b.mean()) ** 2)
        # standard errors on the exponents
        dof = max(1, len(b) - 3)
        cov = (ss / dof) * np.linalg.pinv(A.T @ A)
        out.update(alpha_d=float(coef[1]), beta_m=float(coef[2]),
                   alpha_d_err=float(np.sqrt(cov[1, 1])),
                   beta_m_err=float(np.sqrt(cov[2, 2])),
                   r2=float(1 - ss / tot) if tot > 0 else float("nan"),
                   predicted_alpha_d=2.0, predicted_beta_m_for_consistency=0.0)
    # per-(d, m) medians for the figure
    grid = {}
    for r in ok:
        grid.setdefault((r["d"], r["m"]), []).append(r["etaT_needed"])
    out["points"] = [dict(d=k[0], m=k[1], etaT_needed=float(np.median(v)),
                          seeds=len(v)) for k, v in sorted(grid.items())]
    summary["claim2_etaT"] = out

# =====================================================================
# Claim 3 control -- cluster noise (exp6)
# =====================================================================
e6 = load("exp6_noise.json")
if e6:
    rows = []
    for sc in sorted({r["sigma_c"] for r in e6}):
        g = [r for r in e6 if r["sigma_c"] == sc]
        K = g[0]["K"]
        tr = np.array([r["train_err_end"] for r in g])   # (seeds, K)
        ts = np.array([r["test_err_end"] for r in g])
        own = np.array([r["train_err_own"] for r in g])
        ls = np.array([r["train_loss_end"] for r in g])
        rows.append(dict(
            sigma_c=float(sc), seeds=len(g), K=K,
            # Theorem 2 asks for the error to be small *uniformly over tasks*,
            # so the max over k is the quantity the claim is about.
            train_err_max=float(tr.mean(0).max()),
            test_err_max=float(ts.mean(0).max()),
            train_err_own_max=float(own.mean(0).max()),
            train_loss_max=float(ls.mean(0).max()),
            train_err_per_task=tr.mean(0).tolist(),
            test_err_per_task=ts.mean(0).tolist()))
    summary["claim3_noise"] = dict(
        d=e6[0]["d"], m=e6[0]["m"], n=e6[0]["n"], K=e6[0]["K"],
        T=e6[0]["T"], eta=e6[0]["eta"], rows=rows)

# =====================================================================
# Claim 6 control -- is the decomposition really violated? (exp7)
# =====================================================================
e7 = load("exp7_decomp_mc.json")
if e7:
    drop = np.array([r["dropped_term"] for r in e7])
    slack = np.array([r["slack"] for r in e7])
    per = []
    for key in sorted({(r["n"], r["m"]) for r in e7}):
        g = [r for r in e7 if (r["n"], r["m"]) == key]
        dd = np.array([r["dropped_term"] for r in g])
        per.append(dict(n=key[0], m=key[1], seeds=len(g),
                        dropped_mean=float(dd.mean()),
                        dropped_sd=float(dd.std(ddof=1)),
                        n_negative=int((dd < 0).sum())))
    summary["claim6_decomp"] = dict(
        n_test=e7[0]["n_test"], runs=len(e7),
        dropped_mean=float(drop.mean()),
        dropped_sd=float(drop.std(ddof=1)),
        dropped_sem=float(drop.std(ddof=1) / np.sqrt(len(drop))),
        dropped_t=float(drop.mean() / (drop.std(ddof=1) / np.sqrt(len(drop)))),
        n_negative=int((drop < 0).sum()),
        violations=int((slack > 1e-12).sum()),
        per_corner=per)

# =====================================================================
# Claims 4/5 -- the corner where the bounds are non-vacuous (exp8)
# =====================================================================
e8 = load("exp8_nonvacuous.json")
if e8:
    rows = []
    for key in sorted({(r["T"], r["m"], r["n"]) for r in e8}):
        g = [r for r in e8 if (r["T"], r["m"], r["n"]) == key]
        gp = np.array([r["gen_gap"] for r in g])
        r3 = np.array([r["rhs_thm3"] for r in g])
        r4 = np.array([r["rhs_thm4"] for r in g])
        rows.append(dict(
            T=key[0], m=key[1], n=key[2], seeds=len(g),
            gap=float(gp.mean()),
            sem=float(gp.std(ddof=1) / np.sqrt(len(gp))),
            exponent_thm3=float(np.mean([r["exponent_thm3"] for r in g])),
            exponent_thm4=float(np.mean([r["exponent_thm4"] for r in g])),
            rhs_thm3=float(r3.mean()), rhs_thm4=float(r4.mean()),
            # slack = how many orders of magnitude the bound sits above the
            # measurement; < ~3 is what "non-vacuous" means in practice.
            slack3=float(np.log10(r3.mean() / abs(gp.mean()))),
            slack4=float(np.log10(r4.mean() / abs(gp.mean()))),
            holds3=bool(gp.mean() <= r3.mean()),
            holds4=bool(gp.mean() <= r4.mean()),
            train_loss_end=float(np.mean([r["train_loss_end"] for r in g]))))
    best = min(rows, key=lambda r: r["slack4"])
    summary["claim45_nonvacuous"] = dict(
        d=e8[0]["d"], K=e8[0]["K"], eta=e8[0]["eta"], runs=len(e8),
        rows=rows, tightest=best,
        n_violations_thm3=int(sum(not r["holds3"] for r in rows)),
        n_violations_thm4=int(sum(not r["holds4"] for r in rows)),
        max_exponent_thm3=float(max(r["exponent_thm3"] for r in rows)),
        max_exponent_thm4=float(max(r["exponent_thm4"] for r in rows)))

with open(os.path.join(RES, "summary.json"), "w") as f:
    json.dump(summary, f, indent=1)
print(json.dumps(summary, indent=1)[:200])
print("\nwrote", os.path.join(RES, "summary.json"))
for k in summary:
    print(" section:", k)