"""merge-accuracy: downstream-ACCURACY benchmark of merge-before/after-alignment.

Imports mergeschool.core (/root/mergeability) READ-ONLY for the merge operators, aligners and
quotient-distance diagnostics; adds the accuracy axis (this file) that the NLL work lacks.
"""
from __future__ import annotations
import os, sys, json, math, gc, time, hashlib
for v in ("OMP_NUM_THREADS","MKL_NUM_THREADS","OPENBLAS_NUM_THREADS","NUMEXPR_NUM_THREADS"):
    os.environ.setdefault(v, "8")
os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
os.environ.setdefault("HF_HOME", "/root/hf_cache_mergeacc")
# VENDORED SNAPSHOT of mergeschool.core. /root/mergeability is another agent's live working tree
# and it is being edited concurrently -- two runs of this study died mid-flight with
# "ImportError: cannot import name 'merge' from 'mergeschool.core' (unknown location)" while its
# package __init__ was mid-rewrite. We take a frozen copy at /root/merge-accuracy/vendor and fall
# back to the original only if the copy is missing. /root/mergeability is never written to.
sys.path.insert(0, "/root/mergeability/src")
if os.path.isdir("/root/merge-accuracy/vendor/mergeschool"):
    sys.path.insert(0, "/root/merge-accuracy/vendor")
sys.path.insert(0, "/root/merge-accuracy")
import numpy as np
import torch
torch.set_num_threads(8)
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig

from mergeschool.core import merge as MG
from mergeschool.core import alignment as AL
from mergeschool.core import metrics as MT

CACHE = "/root/hf_cache_mergeacc"
RES = "/root/merge-accuracy/results"


# ------------------------------------------------------------------ models
def load_model(repo, revision=None, dev="cuda", dtype=torch.float32):
    m = AutoModelForCausalLM.from_pretrained(repo, revision=revision, cache_dir=CACHE,
                                             dtype=dtype, low_cpu_mem_usage=True)
    return m.to(dev).eval()


def load_tok(repo, revision=None):
    t = AutoTokenizer.from_pretrained(repo, revision=revision, cache_dir=CACHE)
    if t.pad_token is None:
        t.pad_token = t.eos_token
    return t


def sd_np(model):
    return {k: v.detach().float().cpu().numpy() for k, v in model.state_dict().items()}


def sd_load(model, sd, dtype=torch.float32):
    with torch.no_grad():
        msd = model.state_dict()
        for k, v in sd.items():
            if k in msd and tuple(msd[k].shape) == tuple(np.shape(v)):
                msd[k].copy_(torch.as_tensor(np.asarray(v), dtype=dtype))
    return model


def shared_keys(a, b):
    return [k for k, v in a.items() if k in b and np.shape(b[k]) == np.shape(v)]


# ------------------------------------------------------------------ accuracy scoring
@torch.no_grad()
def _score_batch(model, tok, ctxs, conts, dev, max_len=1024):
    """sum logprob, per-token mean logprob, and greedy-match flag for each (ctx, cont)."""
    enc_c = [tok(c, add_special_tokens=False)["input_ids"] for c in ctxs]
    enc_t = [tok(t, add_special_tokens=False)["input_ids"] for t in conts]
    seqs, nconts = [], []
    for c, t in zip(enc_c, enc_t):
        if len(t) == 0:
            t = [tok.eos_token_id]
        s = (c + t)[-max_len:]
        seqs.append(s); nconts.append(min(len(t), len(s) - 1))
    L = max(len(s) for s in seqs)
    pad = tok.pad_token_id or 0
    x = torch.full((len(seqs), L), pad, dtype=torch.long)
    for i, s in enumerate(seqs):
        x[i, L - len(s):] = torch.tensor(s)          # left-pad
    x = x.to(dev)
    logits = model(x).logits.float()
    lp = torch.log_softmax(logits[:, :-1], -1)
    tgt = x[:, 1:]
    tok_lp = lp.gather(-1, tgt.unsqueeze(-1)).squeeze(-1)      # (B, L-1)
    greedy_ok = (lp.argmax(-1) == tgt)
    out = []
    for i, n in enumerate(nconts):
        sl = slice(L - 1 - n, L - 1)
        s = tok_lp[i, sl].sum().item()
        out.append((s, s / max(n, 1), bool(greedy_ok[i, sl].all().item()), n,
                    len(conts[i])))
    return out


@torch.no_grad()
def eval_task(model, tok, docs, dev, bs=16, max_len=1024):
    """Returns dict with acc, acc_norm, n. `acc` uses summed logprob (harness default);
    `acc_norm` normalises by continuation character length. Generative tasks (doc['greedy'])
    score exact greedy match of the continuation."""
    reqs = []
    for di, d in enumerate(docs):
        for ci, (c, t) in enumerate(zip(d["ctxs"], d["conts"])):
            reqs.append((di, ci, c, t))
    # sort by length for efficient batching
    order = sorted(range(len(reqs)), key=lambda i: -(len(reqs[i][2]) + len(reqs[i][3])))
    res = [None] * len(reqs)
    for b in range(0, len(order), bs):
        idx = order[b:b + bs]
        sc = _score_batch(model, tok, [reqs[i][2] for i in idx], [reqs[i][3] for i in idx],
                          dev, max_len)
        for i, s in zip(idx, sc):
            res[i] = s
    per_doc = {}
    for (di, ci, _, _), s in zip(reqs, res):
        per_doc.setdefault(di, {})[ci] = s
    correct, correct_norm, hits = [], [], []
    for di, d in enumerate(docs):
        sc = per_doc[di]
        if d.get("greedy"):
            hits.append(int(sc[0][2]))
            correct.append(int(sc[0][2])); correct_norm.append(int(sc[0][2]))
        else:
            n = len(d["ctxs"])
            tot = [sc[c][0] for c in range(n)]
            nrm = [sc[c][0] / max(sc[c][4], 1) for c in range(n)]
            correct.append(int(int(np.argmax(tot)) == d["gold"]))
            correct_norm.append(int(int(np.argmax(nrm)) == d["gold"]))
    a = float(np.mean(correct))
    return {"acc": a, "acc_norm": float(np.mean(correct_norm)), "n": len(docs),
            "stderr": float(np.sqrt(a * (1 - a) / max(len(docs), 1))),
            "items": correct}


# ------------------------------------------------------------------ activations / alignment
def make_blocks(tok, lines, block=512, max_blocks=32, sep="\n\n"):
    ids = tok(sep.join(lines), add_special_tokens=False)["input_ids"]
    n = min(max_blocks, len(ids) // block)
    if n == 0:
        n, block = 1, min(block, len(ids))
    return torch.from_numpy(np.asarray(ids[:n * block], dtype=np.int64).reshape(n, block))


@torch.no_grad()
def capture_acts(model, blocks, dev, n_rows=2048, bs=4, seed=0):
    outs = None
    for i in range(0, blocks.shape[0], bs):
        x = blocks[i:i + bs].to(dev)
        hs = model(x, output_hidden_states=True).hidden_states
        if outs is None:
            outs = [[] for _ in hs]
        for j, h in enumerate(hs):
            outs[j].append(h.float().reshape(-1, h.shape[-1]).cpu())
    rng = np.random.default_rng(seed)
    N = torch.cat(outs[0]).shape[0]
    idx = np.sort(rng.choice(N, size=min(n_rows, N), replace=False))
    return {j: torch.cat(outs[j])[idx].numpy().astype(np.float64) for j in range(len(outs))}


def flores_lines(code="eng_Latn", n=200):
    p = f"/root/goldfish-alignment/data/{code}.jsonl"
    out = []
    with open(p, encoding="utf-8") as f:
        for line in f:
            r = json.loads(line)
            if r.get("text"):
                out.append(r["text"])
    return out[:n]


def align_pair(sd_a, sd_b, hidden_dim, n_heads, acts_a=None, acts_b=None, method="permutation"):
    """Carry B into A's frame. Returns (sd_b_aligned, info)."""
    return AL.align_weights_full(sd_a, sd_b, hidden_dim, acts_a=acts_a, acts_b=acts_b,
                                 n_heads=n_heads, method=method, strict=False, accept_each=True)


def diagnostics(sd_a, sd_b, sd_b_perm, sd_b_orth, acts_a=None, acts_b=None):
    """Pre-merge diagnostic block: quotient distance / coordinate share / CKA."""
    keys = shared_keys(sd_a, sd_b)
    d = {}
    for tag, sdb in (("perm", sd_b_perm), ("orth", sd_b_orth)):
        q = MT.quotient_weight_distance(sd_a, sd_b, sdb, keys)
        for k, v in q.items():
            if k != "n_params":
                d[f"{k}_{tag}"] = v
    a = np.concatenate([np.asarray(sd_a[k], float).ravel() for k in keys])
    b = np.concatenate([np.asarray(sd_b[k], float).ravel() for k in keys])
    d["weight_cosine"] = float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))
    if acts_a is not None and acts_b is not None:
        L = sorted(set(acts_a) & set(acts_b))
        ck = [MT.cka(acts_a[l], acts_b[l]) for l in L]
        d["cka_mean"] = float(np.mean(ck)); d["cka_last"] = float(ck[-1])
        try:
            qr = MT.quotient_residual(acts_a[L[-1]], acts_b[L[-1]], group="perm")
            d["qmd_act_perm"] = float(qr["distance"])          # 1 - post-alignment CKA
            d["aligned_cka_perm"] = float(qr["aligned_cka"])
        except Exception:
            d["qmd_act_perm"] = d["aligned_cka_perm"] = float("nan")
    # THE diagnostic the selection experiment uses: block-normalised coordinate share, the
    # fraction of the scale-free parameter distance that the alignment map removes.
    d["coord_share"] = max(d.get("coord_fraction_bn_perm", 0.0) or 0.0,
                           d.get("coord_fraction_bn_orth", 0.0) or 0.0)
    return d


# ------------------------------------------------------------------ merge
def interp(a, b, t, keys=None):
    keys = keys or list(a)
    return {k: (1 - t) * np.asarray(a[k], float) + t * np.asarray(b[k], float) for k in keys}


def ties_merge(base, exp_a, exp_b, density=0.2):
    return MG.ties(base, [exp_a, exp_b], density=density)


def jload(p):
    if not os.path.exists(p): return {}
    out = {}
    with open(p) as f:
        for line in f:
            try:
                r = json.loads(line); out[r["key"]] = r
            except Exception: pass
    return out


def jappend(p, rec):
    os.makedirs(os.path.dirname(p), exist_ok=True)
    with open(p, "a") as f:
        f.write(json.dumps(rec) + "\n"); f.flush(); os.fsync(f.fileno())


# ------------------------------------------------------------------ tokenizer-agnostic acts
@torch.no_grad()
def capture_acts_sent(model, tok, sents, dev, bs=8, max_len=256):
    """{layer: (n_sent, d)} mean-pooled residual states, ONE ROW PER SENTENCE. Row-aligned across
    models even when the two tokenizers differ (rung 4), which token-level capture is not."""
    outs = None
    for i in range(0, len(sents), bs):
        batch = sents[i:i + bs]
        enc = tok(batch, return_tensors="pt", padding=True, truncation=True, max_length=max_len)
        enc = {k: v.to(dev) for k, v in enc.items()}
        hs = model(**enc, output_hidden_states=True).hidden_states
        m = enc["attention_mask"].unsqueeze(-1).float()
        if outs is None:
            outs = [[] for _ in hs]
        for j, h in enumerate(hs):
            outs[j].append(((h.float() * m).sum(1) / m.sum(1).clamp(min=1)).cpu())
    return {j: torch.cat(outs[j]).numpy().astype(np.float64) for j in range(len(outs))}


def body_keys(sd_a, sd_b):
    """Shared keys with equal shapes, EXCLUDING the token embedding / unembedding. For a
    cross-tokenizer pair these are exactly the mergeable parameters; for a same-tokenizer pair
    they are the whole transformer body and we merge the embeddings too (see merge_keys)."""
    sk = shared_keys(sd_a, sd_b)
    return [k for k in sk if not any(s in k for s in ("embed_in", "embed_out", "embed_tokens", "lm_head"))]


def merge_keys(sd_a, sd_b):
    sk = shared_keys(sd_a, sd_b)
    bk = body_keys(sd_a, sd_b)
    return (sk, "full") if len(sk) == len(bk) + 0 and len(sk) > len(bk) else (
        (sk, "full") if len(sk) > len(bk) and _emb_match(sd_a, sd_b) else (bk, "body_only"))


def _emb_match(sd_a, sd_b):
    for k in sd_a:
        if "embed_in" in k or "embed_tokens" in k:
            return k in sd_b and np.shape(sd_a[k]) == np.shape(sd_b[k])
    return False


# ------------------------------------------------------------------ generation (IFEval)
LLAMA31_CHAT = ("<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n"
                "{content}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n")

@torch.no_grad()
def generate_batch(model, tok, prompts, dev, bs=16, max_new=256, max_len=1024):
    """Greedy decoding, left-padded. Used for IFEval, where the constraint is on the TEXT."""
    outs = []
    order = sorted(range(len(prompts)), key=lambda i: -len(prompts[i]))
    res = [None] * len(prompts)
    tok.padding_side = "left"
    for b in range(0, len(order), bs):
        idx = order[b:b + bs]
        enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
                  truncation=True, max_length=max_len, add_special_tokens=False).to(dev)
        gen = model.generate(**enc, max_new_tokens=max_new, do_sample=False,
                             pad_token_id=tok.pad_token_id)
        for j, i in enumerate(idx):
            res[i] = tok.decode(gen[j][enc["input_ids"].shape[1]:], skip_special_tokens=True)
    return res


def eval_ifeval(model, tok, dev, n=200, bs=16, max_new=256):
    import ifeval
    rows = ifeval.docs(n)
    prompts = [LLAMA31_CHAT.format(content=r["prompt"]) for r in rows]
    resp = generate_batch(model, tok, prompts, dev, bs=bs, max_new=max_new)
    return ifeval.score(rows, resp), resp