"""SET 1: PolyPythia seed-merge. EleutherAI/pythia-{size}-seed{1..9}, C(9,2)=36 pairs.
Same data, same arch, same tokenizer; only the init/data-order seed varies -> the merge
obstruction is PURELY COORDINATE. Rungs M0 naive / M1 unit-aligned / task-arith / TIES.
Metric: Delta-floor in nats/token on a held-out corpus (FLORES-200 eng_Latn devtest)."""
import os, sys, json, time, itertools, argparse, gc
sys.path.insert(0, "/root/compose-audit")
from common import *
from transformers import AutoModelForCausalLM, AutoTokenizer

ap = argparse.ArgumentParser()
ap.add_argument("--size", default="14m")
ap.add_argument("--base", default=None, help="repo stem for tokenizer/pseudo-base; defaults to pythia-<size>")
ap.add_argument("--seeds", default="1,2,3,4,5,6,7,8,9")
ap.add_argument("--blocks", type=int, default=48)
ap.add_argument("--bs", type=int, default=16)
ap.add_argument("--barrier_n", type=int, default=7)
ap.add_argument("--acts_rows", type=int, default=2048)
ap.add_argument("--tag", default="set1")
A = ap.parse_args()
BASE_STEM = A.base or f"pythia-{A.size}"
SEEDS = [int(s) for s in A.seeds.split(",")]
OUT = f"/root/compose-audit/results/{A.tag}_{A.size}.jsonl"
DEV = "cuda"


def log(*a):
    print(f"[{time.strftime('%H:%M:%S')}]", *a, flush=True)


# ------------------------------------------------------------------ local: GPTNeoX fused-QKV head perm
def neox_head_match(sd_a, sd_b, d, n_heads, nlayer):
    hd = d // n_heads
    perms = {}
    for L in range(nlayer):
        qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight"
        de = f"gpt_neox.layers.{L}.attention.dense.weight"
        if qk not in sd_a or qk not in sd_b:
            continue
        A_ = np.asarray(sd_a[qk], float).reshape(n_heads, 3 * hd, d)
        B_ = np.asarray(sd_b[qk], float).reshape(n_heads, 3 * hd, d)
        gain = np.einsum("ixy,jxy->ij", A_, B_)
        Ad = np.asarray(sd_a[de], float).reshape(d, n_heads, hd)
        Bd = np.asarray(sd_b[de], float).reshape(d, n_heads, hd)
        gain = gain + np.einsum("xiy,xjy->ij", Ad, Bd)
        perms[L] = AL._assignment(gain)
    return perms


def neox_apply_head(sd, perms, d, n_heads):
    hd = d // n_heads
    out = dict(sd)
    for L, h in perms.items():
        qk = f"gpt_neox.layers.{L}.attention.query_key_value.weight"
        qb = f"gpt_neox.layers.{L}.attention.query_key_value.bias"
        de = f"gpt_neox.layers.{L}.attention.dense.weight"
        out[qk] = np.asarray(sd[qk], float).reshape(n_heads, 3 * hd, d)[h].reshape(3 * d, d)
        if qb in sd:
            out[qb] = np.asarray(sd[qb], float).reshape(n_heads, 3 * hd)[h].reshape(3 * d)
        out[de] = np.asarray(sd[de], float).reshape(d, n_heads, hd)[:, h].reshape(d, d)
    return out


def align_full(sd_a, sd_b, d, acts_a, acts_b, n_heads, nlayer, method):
    """AL.align_weights_full (residual basis + free MLP axis) + a GPTNeoX fused-QKV head factor,
    each accepted only if it does not increase the scale-free block-normalised distance."""
    sd, info = AL.align_weights_full(sd_a, sd_b, d, acts_a=acts_a, acts_b=acts_b,
                                     n_heads=None, method=method, strict=True, accept_each=True)
    hp = neox_head_match(sd_a, sd, d, n_heads, nlayer)
    if hp:
        cand = neox_apply_head(sd, hp, d, n_heads)
        if AL.block_normalised_distance(sd_a, cand) <= AL.block_normalised_distance(sd_a, sd):
            sd, info["heads"] = cand, len(hp)
        else:
            info["rejected"].append("heads")
    return sd, info


# ------------------------------------------------------------------ setup
tok = AutoTokenizer.from_pretrained(f"EleutherAI/{BASE_STEM}")
lines = flores_lines("eng_Latn")
blocks = make_blocks(tok, lines, block=512, max_blocks=A.blocks)
log(f"size={A.size} blocks={tuple(blocks.shape)} tokens={blocks.numel()}")

shell = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{SEEDS[0]}",
                                             dtype=torch.float32).to(DEV).eval()
cfg = shell.config
D, NH, NL = cfg.hidden_size, cfg.num_attention_heads, cfg.num_hidden_layers
log(f"d={D} heads={NH} layers={NL} params={sum(p.numel() for p in shell.parameters())/1e6:.1f}M")


def ev(sd):
    sd_load(shell, sd, DEV)
    return nll_nats(shell, blocks, DEV, bs=A.bs)


SDS, NLL, ACTS = {}, {}, {}
for s in SEEDS:
    m = AutoModelForCausalLM.from_pretrained(f"EleutherAI/pythia-{A.size}-seed{s}", dtype=torch.float32).to(DEV).eval()
    SDS[s] = sd_np(m)
    NLL[s] = nll_nats(m, blocks, DEV, bs=A.bs)
    ACTS[s] = capture_acts(m, blocks, DEV, n_rows=A.acts_rows, bs=A.bs)
    del m; torch.cuda.empty_cache()
    log(f"  seed{s} nll={NLL[s]:.4f}")

BASE = None
try:
    mb = AutoModelForCausalLM.from_pretrained(f"EleutherAI/{BASE_STEM}", dtype=torch.float32).to(DEV).eval()
    BASE = sd_np(mb); BASE_NLL = nll_nats(mb, blocks, DEV, bs=A.bs)
    del mb; torch.cuda.empty_cache()
    log(f"  base({BASE_STEM}, NOT a shared ancestor of the seeds) nll={BASE_NLL:.4f}")
except Exception as e:
    log("base load failed:", e)

KEYS = shared_keys(SDS[SEEDS[0]], SDS[SEEDS[1]])
done = set()
if os.path.exists(OUT):
    for line in open(OUT):
        try: done.add(tuple(json.loads(line)["pair"]))
        except Exception: pass
log(f"resuming: {len(done)} pairs already done")

fh = open(OUT, "a")
for a, b in itertools.combinations(SEEDS, 2):
    if (a, b) in done:
        continue
    t0 = time.time()
    sa, sb = SDS[a], SDS[b]
    r = {"set": "set1_polypythia", "size": A.size, "pair": [a, b],
         "parent_nll": {"a": NLL[a], "b": NLL[b]}, "floor": min(NLL[a], NLL[b]),
         "corpus": "flores200_devtest_eng_Latn", "metric": "nats_per_token"}

    # ---------------- alignments (fitted BEFORE any merge) ----------------
    sb_perm, info_p = align_full(sa, sb, D, ACTS[a], ACTS[b], NH, NL, "permutation")
    sb_orth, info_o = align_full(sa, sb, D, ACTS[a], ACTS[b], NH, NL, "orthogonal")
    r["align_info"] = {"perm": info_p, "orth": info_o}

    # ---------------- predictors (pre-merge) ----------------
    fa, fb = flat(sa, KEYS), flat(sb, KEYS)
    p = {"weight_cosine": float(fa @ fb / (np.linalg.norm(fa) * np.linalg.norm(fb)))}
    p["weight_cosine_bn"] = float(np.mean([
        float(np.asarray(sa[k], float).ravel() @ np.asarray(sb[k], float).ravel() /
              (np.linalg.norm(sa[k]) * np.linalg.norm(sb[k]) + 1e-12)) for k in KEYS]))
    qwd_p = MT.quotient_weight_distance(sa, sb, sb_perm, KEYS)
    qwd_o = MT.quotient_weight_distance(sa, sb, sb_orth, KEYS)
    p.update({"d_raw": qwd_p["d_raw"], "qmd_perm": qwd_p["qmd"],
              "coord_share_perm": qwd_p["coord_fraction"], "norm_ratio_perm": qwd_p["norm_ratio"],
              "qmd_orth": qwd_o["qmd"], "coord_share_orth": qwd_o["coord_fraction"]})
    for tag, extra in (("perm", qwd_p), ("orth", qwd_o)):
        for k in ("d_raw_bn", "qmd_bn", "coordinate_gap_bn", "coord_fraction_bn"):
            if k in extra:
                p[f"{k}_{tag}"] = extra[k]
    bnd_raw = AL.block_normalised_distance(sa, sb, KEYS)
    bnd_p = AL.block_normalised_distance(sa, sb_perm, KEYS)
    bnd_o = AL.block_normalised_distance(sa, sb_orth, KEYS)
    p.update({"bnd_raw": bnd_raw, "bnd_perm": bnd_p, "bnd_orth": bnd_o,
              "coord_share_bnd_perm": float((bnd_raw - bnd_p) / bnd_raw),
              "coord_share_bnd_orth": float((bnd_raw - bnd_o) / bnd_raw)})
    ck, ck_by = mean_cka(ACTS[a], ACTS[b])
    p["cka_mean"] = ck; p["cka_last"] = ck_by[max(ck_by)]
    mid = NL // 2
    for g in ("perm", "procrustes", "ot"):
        try:
            qr = MT.quotient_residual(ACTS[a][mid], ACTS[b][mid], group=g)
            p[f"qmd_act_{g}"] = qr["distance"]; p[f"aligned_cka_{g}"] = qr["aligned_cka"]
        except Exception as e:
            p[f"qmd_act_{g}"] = float("nan")
    if BASE is not None:
        ta = flat({k: sa[k] - BASE[k] for k in KEYS}, KEYS)
        tb = flat({k: sb[k] - BASE[k] for k in KEYS}, KEYS)
        p["task_vector_cosine"] = float(ta @ tb / (np.linalg.norm(ta) * np.linalg.norm(tb)))
    r["predictors"] = p

    # ---------------- merge rungs ----------------
    rungs = {}
    rungs["M0_naive_avg"] = MG.average([sa, sb])
    rungs["M1_perm_avg"] = MG.average([sa, sb_perm])
    rungs["M1_orth_avg"] = MG.average([sa, sb_orth])
    if BASE is not None:
        rungs["M2_task_arith"] = MG.task_arithmetic(BASE, [sa, sb])
        try:
            rungs["M3_ties"] = MG.ties(BASE, [sa, sb], density=0.2)
        except Exception as e:
            log("ties failed", e)
    res = {}
    for name, sd in rungs.items():
        n = ev(sd)
        res[name] = {"nll": n, "delta_floor": n - r["floor"],
                     "delta_vs_naive": None}
    for name in res:
        res[name]["delta_vs_naive"] = res[name]["nll"] - res["M0_naive_avg"]["nll"]
    r["rungs"] = res

    # ---------------- barriers ----------------
    try:
        bn = EV.merge_barrier(sa, sb, ev, n=A.barrier_n)
        r["barrier_naive"] = {"barrier": bn["barrier"], "losses": list(map(float, bn["losses"]))}
        bp = EV.merge_barrier(sa, sb_perm, ev, n=A.barrier_n)
        r["barrier_perm"] = {"barrier": bp["barrier"], "losses": list(map(float, bp["losses"]))}
    except Exception as e:
        log("barrier failed", e)

    r["secs"] = time.time() - t0
    fh.write(json.dumps(r) + "\n"); fh.flush()
    log(f"pair {a},{b}  floor={r['floor']:.3f}  M0={res['M0_naive_avg']['delta_floor']:+.3f}  "
        f"M1perm={res['M1_perm_avg']['delta_floor']:+.3f}  M1orth={res['M1_orth_avg']['delta_floor']:+.3f}  "
        f"({r['secs']:.0f}s)")
    del rungs, sb_perm, sb_orth; gc.collect()
fh.close()
log("DONE", A.size)