"""Score Exp 0 smoke runs and compare configs. Usage: python score_smoke.py V-BF16 V-FP8 ...

Joins vllm bench serve `generated_texts[i]` with smoke JSONL row i (inputs are unshuffled),
then reports per-dataset accuracy. LCB is not executed here: it only checks that a code
block was produced. KL is computed between each config and the first one.
"""
import json
import math
import re
import sys
from pathlib import Path

B = Path.home() / "bench"
S = B / "data" / "smoke"
FILES = {"ruler_4k": "ruler_4k_26.jsonl", "ruler_128k": "ruler_128k_13.jsonl",
         "docvqa": "docvqa_20.jsonl", "gpqa": "gpqa_8.jsonl", "lcb": "lcb_10.jsonl"}


def lev(a, b):
    prev = list(range(len(b) + 1))
    for i, ca in enumerate(a, 1):
        cur = [i]
        for j, cb in enumerate(b, 1):
            cur.append(min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb)))
        prev = cur
    return prev[-1]


def anls(pred, answers):
    p = pred.strip().lower()
    best = 0.0
    for g in answers:
        g = g.strip().lower()
        nl = lev(p, g) / max(len(p), len(g), 1)
        best = max(best, 1 - nl if nl < 0.5 else 0.0)
    return best


def score(ds, row, text):
    if ds.startswith("ruler"):
        return sum(a.lower() in text.lower() for a in row["answers"]) / len(row["answers"])
    if ds == "docvqa":
        return anls(text.strip().split("\n")[-1], row["answers"])
    if ds == "gpqa":
        m = re.findall(r"ANSWER:\s*\(?([ABCD])\)?", text)
        return float(bool(m) and m[-1] == row["correct_letter"])
    if ds == "lcb":
        return float("```python" in text)


def kl(p_top, q_top):
    """KL(P||Q) over P's top-k; Q's missing tokens get Q's smallest logprob."""
    q = dict(q_top)
    floor = min(q.values()) if q else -30.0
    return sum(math.exp(lp) * (lp - q.get(t, floor)) for t, lp in p_top)


cfgs = sys.argv[1:]
print(f"{'dataset':<12}" + "".join(f"{c:>14}" for c in cfgs))
for ds, fn in FILES.items():
    rows = [json.loads(l) for l in open(S / fn)]
    line = f"{ds:<12}"
    for c in cfgs:
        f = B / "exp0" / c / f"{ds}.json"
        if not f.exists():
            line += f"{'missing':>14}"
            continue
        res = json.loads(f.read_text())
        texts, errs = res["generated_texts"], res.get("errors", [])
        vals = [score(ds, r, t) for r, t in zip(rows, texts)]
        nerr = sum(1 for e in errs if e)
        line += f"{sum(vals) / len(vals):>10.3f}" + (f" e{nerr:<2}" if nerr else "    ")
    print(line)

base = B / "exp0" / cfgs[0] / "kl_probe.json"
if base.exists():
    P = json.loads(base.read_text())
    print(f"\nKL vs {cfgs[0]} (mean per token) / top-1 agreement")
    for c in cfgs[1:]:
        f = B / "exp0" / c / "kl_probe.json"
        if not f.exists():
            print(f"{c}: missing"); continue
        Q = json.loads(f.read_text())
        kls, agree, n = 0.0, 0, 0
        for tp, tq in zip(P, Q):
            for pp, qq in zip(tp["positions"], tq["positions"]):
                if pp["top"] and qq["top"]:
                    kls += kl(pp["top"], qq["top"]); agree += pp["top"][0][0] == qq["top"][0][0]; n += 1
        print(f"{c}: KL={kls / max(n, 1):.5f}  top1={agree / max(n, 1):.4f}  tokens={n}")