"""POSITIVE CONTROL with GROUND TRUTH.

Take a real fork and act on it by a RANDOM element of the model's own symmetry group (per-layer
free-hidden-axis permutation + attention-head permutation). The permuted fork is *functionally
identical* -- same accuracy on every benchmark, exactly -- but it now lives in a different
parameterisation. The base model's chat vector is therefore being added in the wrong frame.

Ground truth: naive must collapse, and alignment must recover EXACTLY the unpermuted naive result.
This is the only cell in the study where we know the right answer in advance, so it tells us
whether the diagnostic's decision rule fires when it should, and calibrates the threshold.

usage: cv_control.py <forks.json> <gpu> <lambda> <fractions e.g. 0.125,0.25,0.5,1.0>
"""
import os, sys, json, time, gc, traceback
os.environ["CUDA_VISIBLE_DEVICES"] = sys.argv[2]
import numpy as np, torch
import ma_common as C, tasks as TK, gmap
from mergeschool.core import alignment as AL, metrics as MT

FORKS = json.load(open(sys.argv[1]))
LAM = float(sys.argv[3])
FRACS = [float(x) for x in (sys.argv[4] if len(sys.argv) > 4 else "1.0").split(",")]
LEDGER = os.environ.get("MA_LEDGER", "/root/merge-accuracy/results/chatvec.jsonl")
NBEL = int(os.environ.get("MA_NBEL", "300")); NENG = int(os.environ.get("MA_NENG", "500"))
BS = int(os.environ.get("MA_BS", "16"))
NIF = int(os.environ.get("MA_NIF", "200"))
BASE = "meta-llama/Llama-3.1-8B"; INST = "meta-llama/Llama-3.1-8B-Instruct"
DEV, DT = "cuda", torch.bfloat16
done = C.jload(LEDGER)

def put(k, rec):
    rec["key"] = k; rec["t"] = time.time(); C.jappend(LEDGER, rec); done[k] = rec
    print(f"[{time.strftime('%H:%M:%S')}] {k}  " +
          " ".join(f"{t}={v:.4f}" for t, v in rec.get("acc", {}).items()), flush=True)

def evaluate(model, tok, langs):
    """Three axes: target-language capability, instruction following, English retention."""
    out = {}
    if isinstance(langs, str): langs = [langs]
    for lg in langs:
        out[f"belebele_{lg}"] = C.eval_task(model, tok, TK.belebele(lg, NBEL), DEV, bs=BS)["acc"]
    out["belebele_eng_Latn"] = C.eval_task(model, tok, TK.belebele("eng_Latn", NBEL), DEV, bs=BS)["acc"]
    out["arc_easy"] = C.eval_task(model, tok, TK.arc_easy(NENG), DEV, bs=BS)["acc"]
    ife, _ = C.eval_ifeval(model, tok, DEV, n=NIF, bs=max(BS // 2, 4))
    out["ifeval_prompt"] = ife["ifeval_prompt"]; out["ifeval_inst"] = ife["ifeval_inst"]
    return out

mb = C.load_model(BASE, dev="cpu", dtype=torch.float32)
sd_base = C.sd_np(mb); cfg = mb.config; HID, NH = cfg.hidden_size, cfg.num_attention_heads
NKV = getattr(cfg, "num_key_value_heads", NH)
del mb; gc.collect()
mi = C.load_model(INST, dev="cpu", dtype=torch.float32); sd_inst = C.sd_np(mi); del mi; gc.collect()
KEYS = C.shared_keys(sd_base, sd_inst)
tau = {k: sd_inst[k] - sd_base[k] for k in KEYS}; del sd_inst; gc.collect()
tok_base = C.load_tok(BASE); sents = C.flores_lines("eng_Latn", 256)
m = C.load_model(BASE, dev=DEV, dtype=DT); acts_base = C.capture_acts_sent(m, tok_base, sents, DEV)
del m; gc.collect(); torch.cuda.empty_cache()
print("base+tau ready", flush=True)

F = FORKS[0]
mf = C.load_model(F["repo"], dev="cpu", dtype=torch.float32)
sd_fork0 = C.sd_np(mf); del mf; gc.collect()
tok_f = C.load_tok(F["repo"]); lang = F["lang"]
mm = C.load_model(F["repo"], dev=DEV, dtype=DT)
LAYER_PRES = sorted({p for p in (AL._layer_prefix(n) for n in sd_fork0) if p})
AXES = AL.free_hidden_axes(sd_fork0, HID)

for frac in FRACS:
    name = f'{F["name"]}_PERM{frac}'
    try:
        rng = np.random.default_rng(int(frac * 1000))
        npick = max(1, int(round(frac * len(LAYER_PRES))))
        picked = set(rng.choice(LAYER_PRES, size=npick, replace=False).tolist())
        hperm = {pre: rng.permutation(ax["f"]) for pre, ax in AXES.items() if pre in picked}
        sd_fork = AL.apply_hidden_perms(sd_fork0, hperm, HID)
        aperm = gmap.random_gqa_head_perms(sd_fork0, HID, NH, NKV, rng, only=picked)
        sd_fork = gmap.apply_gqa_head_perms(sd_fork, aperm, HID, NH, NKV)
        print(f"### {name}: permuted {npick}/{len(LAYER_PRES)} layers", flush=True)

        k = f"{name}|fork_alone"
        if k not in done:
            C.sd_load(mm, sd_fork, dtype=DT)
            put(k, {"kind": "control", "fork": name, "arm": "fork_alone", "lam": None, "lang": lang,
                    "frac_layers_permuted": frac, "model": F["repo"],
                    "acc": evaluate(mm, tok_f, [lang]),
                    "note": "random symmetry-group action: must match the unpermuted fork exactly"})

        C.sd_load(mm, sd_fork, dtype=DT)
        acts_f = C.capture_acts_sent(mm, tok_f, sents, DEV)

        kd = f"{name}|diag"
        if kd not in done:
            t0 = time.time()
            g, info = gmap.fit_g(sd_fork, sd_base, HID, NH, acts_f, acts_base, "permutation", verbose=False, n_kv_heads=NKV)
            a = np.concatenate([sd_base[x].ravel() for x in KEYS]); b = np.concatenate([sd_fork[x].ravel() for x in KEYS])
            info["weight_cosine_vs_base"] = float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))
            info["rel_drift"] = float(np.linalg.norm(a - b) / np.linalg.norm(a)); del a, b; gc.collect()
            L = sorted(set(acts_f) & set(acts_base))
            info["cka_mean"] = float(np.mean([MT.cka(acts_base[l], acts_f[l]) for l in L]))
            info["cka_last"] = float(MT.cka(acts_base[L[-1]], acts_f[L[-1]]))
            info["coord_share"] = info["coord_share_bn"]
            info["PREDICTION_align_helps"] = bool(info["coord_share"] >= 0.01)
            info["fit_seconds"] = time.time() - t0
            info["frac_layers_permuted"] = frac
            info = {kk: (v.tolist() if isinstance(v, np.ndarray) else v) for kk, v in info.items()}
            np.save(f"/root/merge-accuracy/results/g_{name}.npy", np.array([g], dtype=object), allow_pickle=True)
            put(kd, {"kind": "diag", "fork": name, "arm": "diag", "lang": lang, "diag": info})
            print(f"  DIAG {name}: coord_share={info['coord_share']:.4f} identity={info['is_identity']} "
                  f"hidden={info['hidden']} heads={info['heads']} {info['fit_seconds']:.0f}s", flush=True)
        else:
            g = np.load(f"/root/merge-accuracy/results/g_{name}.npy", allow_pickle=True)[0]
        diag = done[kd]["diag"]
        del acts_f; gc.collect()

        tau_al = gmap.apply_g(tau, g, HID, NH)
        for arm, tv in (("naive", tau), ("aligned", tau_al)):
            k = f"{name}|{arm}|lam{LAM}"
            if k in done: continue
            sd_m = {kk: sd_fork[kk] + LAM * tv[kk] for kk in KEYS}
            C.sd_load(mm, sd_m, dtype=DT)
            put(k, {"kind": "control", "fork": name, "arm": arm, "lam": LAM, "lang": lang,
                    "frac_layers_permuted": frac, "coord_share": diag["coord_share"],
                    "acc": evaluate(mm, tok_f, [lang])})
            del sd_m; gc.collect()
        del tau_al, sd_fork; gc.collect()
    except Exception:
        print(f"!! CONTROL FAIL {name}\n" + traceback.format_exc()[-2000:], flush=True)
        gc.collect(); torch.cuda.empty_cache()
print("CONTROL_DONE", flush=True)