import argparse
import json

import torch
from transformers import AutoTokenizer

from alea.eval import load_model, predict_all


def convert(row, tier):
    question = row["question"]
    qtype = question["type"]
    expected = row["expected"]
    labels = [str(label) for label in row["labels"]]
    criteria = question.get("criteria") or question.get("levels") or {}
    if isinstance(criteria, list):
        values = criteria
    elif isinstance(criteria, dict):
        values = list(criteria.values())
    else:
        values = labels

    if qtype == "noul":
        qcriteria = criteria if isinstance(criteria, dict) else {}
        target = float(str(expected).lower() in ("yes", "true", "1"))
        spec = {"type": qtype, "instructions": question["instructions"],
                "criteria": qcriteria}
        targets = {"q": target}
    elif qtype == "score":
        qlevels = dict(zip(labels, map(str, values)))
        gold = str(expected)
        if gold not in qlevels:
            raise ValueError(f"{row['id']}: score gold {gold!r} not in {labels}")
        spec = {"type": qtype, "instructions": question["instructions"],
                "levels": qlevels}
        targets = {"q": [float(label == gold) for label in qlevels]}
    elif qtype == "choice":
        if isinstance(criteria, dict):
            qcriteria = {str(key): str(value)
                         for key, value in criteria.items()}
        else:
            qcriteria = dict(zip(labels, map(str, values)))
        gold = str(expected)
        if gold not in qcriteria:
            raise ValueError(f"{row['id']}: choice gold {gold!r} not in "
                             f"{list(qcriteria)}")
        spec = {"type": qtype, "instructions": question["instructions"],
                "criteria": qcriteria}
        targets = {"q": [float(label == gold) for label in qcriteria]}
    else:
        raise ValueError(f"{row['id']}: unsupported type {qtype!r}")

    return {"id": f"jevpub:{tier}:{row['id']}",
            "family": row["family"], "state": row["state"],
            "questions": {"q": spec}, "targets": targets}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ckpt", required=True)
    ap.add_argument("--bench-root", default="/root/jevbench")
    ap.add_argument("--model", default="Qwen/Qwen3-0.6B")
    ap.add_argument("--max-len", type=int, default=4096)
    ap.add_argument("--tiers", nargs="+", default=["easy", "hard", "original"])
    args = ap.parse_args()

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    tokenizer = AutoTokenizer.from_pretrained(args.model)
    model = load_model(args.ckpt, args.model, device)
    result = {"checkpoint": args.ckpt, "max_len": args.max_len, "tiers": {}}

    for tier in args.tiers:
        path = f"{args.bench_root}/datasets/public/{tier}.jsonl"
        raw_rows = [json.loads(line) for line in open(path, encoding="utf-8")]
        rows = [convert(row, tier) for row in raw_rows]
        preds = predict_all(model, tokenizer, rows, device, max_len=args.max_len)
        n = correct = 0
        by_family = {}
        by_type = {}
        confidence = []
        for row in rows:
            qid = "q"
            spec = row["questions"][qid]
            target = row["targets"][qid]
            pred = preds[row["id"]][qid]
            if spec["type"] in ("choice", "score"):
                gold_i = max(range(len(target)), key=lambda i: target[i])
                pred_i = max(range(len(pred["probs"])),
                             key=lambda i: pred["probs"][i])
                conf = max(pred["probs"])
                is_correct = int(gold_i == pred_i)
            else:
                p_yes = pred["p"]
                conf = max(p_yes, 1 - p_yes)
                is_correct = int((p_yes >= 0.5) == (target >= 0.5))
            n += 1
            correct += is_correct
            family = row["family"]
            by_family.setdefault(family, [0, 0])
            by_family[family][0] += is_correct
            by_family[family][1] += 1
            by_type.setdefault(spec["type"], [0, 0])
            by_type[spec["type"]][0] += is_correct
            by_type[spec["type"]][1] += 1
            confidence.append((conf, is_correct))

        bins = [[] for _ in range(10)]
        for conf, is_correct in confidence:
            bins[min(9, int(conf * 10))].append((conf, is_correct))
        ece = sum(len(bucket) / n * abs(
            sum(c for c, _ in bucket) / len(bucket) -
            sum(ok for _, ok in bucket) / len(bucket))
                   for bucket in bins if bucket)
        result["tiers"][tier] = {
            "n": n, "correct": correct, "accuracy": correct / n,
            "ece10": ece,
            "by_family": {key: round(ok / count, 4)
                          for key, (ok, count) in sorted(by_family.items())},
            "by_type": {key: {"n": count, "accuracy": ok / count}
                        for key, (ok, count) in sorted(by_type.items())},
        }

    print(json.dumps(result, indent=2, sort_keys=True))


if __name__ == "__main__":
    main()