"""Run Alea on JevBench public datasets -> per-tier accuracy/ECE/Brier/latency.

Maps JevBench tasks to Alea packing:
  choice -> choice q, options=labels, descs=criteria[label]
  noul   -> noul q, probs {yes,no}
  score  -> choice q over level labels (native dist over exact label set)
"""
import json, sys, time
sys.path.insert(0, "/root/alea")
sys.path.insert(0, "/root/jevbench")
import numpy as np
import torch
import torch.nn.functional as F

from alea.model import AleaModel, collate_segments, mask_from_segments
from alea.packing import pack_request, QuestionSpec
from alea.train import load_into
from jevbench.tasks import load_jsonl
from jevbench.scoring import score_task
from jevbench.metrics import brier_score, ece_top_label, latency_summary, macro_accuracy

CKPT = sys.argv[1] if len(sys.argv) > 1 else "/root/alea/checkpoints/alea_env_rl.pt"
MAXLEN = 4096
dev = torch.device("cuda")

from transformers import AutoTokenizer
tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
model = AleaModel("Qwen/Qwen3-0.6B", attn_impl="sdpa",
                  use_aux_embed=True, use_ngram=True, use_ngram2=True, use_ngram3=True).to(dev)
load_into(model, CKPT)
model.eval()
pad = tok.pad_token_id or tok.eos_token_id


def task_to_spec(t):
    qt = t.question["type"]
    instr = t.question["instructions"]
    crit = t.question.get("criteria")
    keys = [str(l) for l in t.labels]
    if qt == "noul":
        return QuestionSpec(qid="decision", qtype="noul",
                            instructions=instr, options=[], option_keys=["no", "yes"])
    if isinstance(crit, dict):
        opts = [str(crit.get(l, l)) for l in t.labels]
    elif isinstance(crit, list):
        opts = [str(x) for x in crit]
    else:
        opts = keys[:]
    return QuestionSpec(qid="decision", qtype="choice", instructions=instr,
                        options=opts, option_keys=keys)


@torch.no_grad()
def decide(t):
    spec = task_to_spec(t)
    st = t.state if isinstance(t.state, str) else json.dumps(t.state, indent=1)
    pk = pack_request(tok, st, [spec], max_len=MAXLEN)
    ids, pos, seg, qof, oof = collate_segments([pk], pad)
    mask = mask_from_segments(seg.to(dev), qof.to(dev), oof.to(dev)).to(torch.bfloat16)
    out = model(ids.to(dev), mask, pos.to(dev), [pk])
    r = out[0][0]
    if spec.qtype == "noul":
        p = float(r["p_yes"].item())
        return {"yes": p, "no": 1.0 - p}
    probs = F.softmax(r["logits"][: len(t.labels)].float(), -1).tolist()
    return {str(l): float(pr) for l, pr in zip(t.labels, probs)}


all_recs = []
for name in ["easy", "hard", "original"]:
    tasks = load_jsonl(f"/root/jevbench/datasets/public/{name}.jsonl")
    recs = []
    for i, t in enumerate(tasks, 1):
        t0 = time.perf_counter()
        try:
            probs = decide(t)
            lat = time.perf_counter() - t0
            s = score_task(probs, t)
            recs.append({"task_id": t.id, "family": t.family, "split": name,
                         "group": t.group, "ok": True, "probs": probs,
                         "state": t.state[:3000],
                         "instructions": t.question.get("instructions",""),
                         "criteria": t.question.get("criteria"),
                         "valid": s["valid"], "correct": s["correct"],
                         "predicted": s.get("predicted"),
                         "ordinal_ev": s.get("ordinal_ev"),
                         "latency_s": lat,
                         "expected": t.expected})
        except Exception as e:
            recs.append({"task_id": t.id, "family": t.family, "split": name,
                         "ok": False, "error": f"{type(e).__name__}: {str(e)[:120]}",
                         "correct": False, "valid": False, "latency_s": time.perf_counter() - t0})
        if i % 25 == 0:
            print("%s: %d/%d" % (name, i, len(tasks)), flush=True)
    all_recs += recs
    scorable = [r for r in recs if r["ok"] and r.get("expected") is not None]
    n = len(scorable)
    acc = sum(r["correct"] for r in scorable) / max(n, 1)
    pairs = [(r["probs"], str(r["expected"]), [str(x) for x in
             [t2.labels for t2 in tasks if t2.id == r["task_id"]][0]])
             for r in scorable]
    briers, ece_pairs = [], []
    for r in scorable:
        t2 = next(x for x in tasks if x.id == r["task_id"])
        exp = str(t2.expected)
        labs = [str(x) for x in t2.labels]
        try:
            briers.append(brier_score(r["probs"], exp, labs))
        except Exception:
            pass
        conf = max(r["probs"].values()); pred = max(r["probs"], key=r["probs"].get)
        ece_pairs.append((conf, float(pred == exp)))
    ece = ece_top_label(ece_pairs)["ece"]
    lat = latency_summary([r["latency_s"] for r in recs])
    # chance-corrected intelligence (jevbench: (acc - chance)/(1 - chance))
    chance = np.mean([1.0 / len(next(x for x in tasks if x.id == r["task_id"]).labels)
                      for r in scorable])
    cci = max(0.0, (acc - chance) / (1 - chance)) * 100 if n else 0.0
    print()
    print("== %s: n=%d acc=%.3f cci=%.1f brier=%.4f ece=%.4f p50=%.3fs p95=%.3fs"
          % (name, n, acc, cci, np.mean(briers), ece,
             lat["p50_s"], lat["p95_s"]))
    # per-family
    fams = {}
    for r in scorable:
        fams.setdefault(r["family"], []).append(r["correct"])
    for f_, v in sorted(fams.items()):
        print("   " + f_.ljust(22), "%d/%d = %.3f" % (sum(v), len(v), np.mean(v)))

out = "/root/alea/jevbench_results.json"
json.dump(all_recs, open(out, "w"), indent=1)
print("wrote", out)

import json as _j
with open("/root/alea/jevbench_dump.jsonl","w") as fh:
    for r in all_recs:
        fh.write(_j.dumps(r)+chr(10))
print("dumped", len(all_recs), "records")