"""Build the HumanEval+ Verifier dataset from local BenchKit HumanEval+ runs.

Each row is one candidate solution to a HumanEval+ problem, written by a model
during a past BenchKit run, and the question "does this pass every test?":

    uv run python scripts/build_code_verifier.py [--results results]

It imports BenchKit's HumanEval+ evaluator, so copy it into the `scripts/`
directory of a BenchKit checkout and run it from there. It writes
`src/benchkit/datasets/code_verifier.jsonl`, the copy BenchKit ships.

Candidates come from `results/*/results.json`, direct-harness humaneval-plus
jobs only, and only from models in `MODELS`, which is an allowlist: a model
that is not listed is never read, so a new or unreleased model cannot slip in
on a rebuild. Rows that timed out, were loop-killed, hit a length limit or
were harness errors are skipped, and so are responses with a `</think>` that
has no opening tag, because the extractor would grade a draft from the
reasoning.

Labels are never taken from the stored `passed` field. Every distinct program
is executed against the base and plus tests with the current evaluator. A
failure is then re-run under generous time limits, and one that passes there
failed only on time and is dropped, since nothing in the problem states a time
budget. Programs that do not compile (usually prose instead of code) are
dropped as too easy to reject.

Selection is deterministic: 250 failing and 250 passing programs, at most
`PER_TASK` of each per task and at most `FAMILY_CAP` of each side from one
model family. The label is the full HumanEval+ suite (base and plus tests).
Failing programs that still pass the base tests are taken first, because a
subtle failure is a harder test than an obvious one. Passing programs mirror
the failing side: the same tasks first, and per family no more than that
family failed, so neither the task nor the coding style predicts the label.
Rows are interleaved fail/pass in a seeded order, so any slice is balanced.
"""

from __future__ import annotations

import argparse
import json
import os
import random
import sys
from collections import Counter, defaultdict
from concurrent.futures import ProcessPoolExecutor
from importlib.metadata import version
from pathlib import Path

ROOT = Path(__file__).parent.parent
sys.path.insert(0, str(ROOT / "src"))

from benchkit.benchmarks import evalplus as ep  # noqa: E402

DATASET_VERSION = "v1"
OUTPUT = ROOT / "src" / "benchkit" / "datasets" / "code_verifier.jsonl"
SEED = 53
PER_SIDE = 250
PER_TASK = 4
FAMILY_CAP = 62  # 25% of one side
EXCLUDED_RUNS = {
    # lfm2.5-2.6b with thinking on, interrupted after 42 tasks.
    "2026-10-08_14-03-09",
}
GENEROUS = {"min_time_limit": 10.0, "gt_time_limit_factor": 50.0}

# Publishable models and the family each one counts against. Default-deny.
# fmt: off
MODELS = {
    "bonsai2-27b-pq2": "bonsai2-27b",
    "bonsai2-27b-pq2-np4": "bonsai2-27b",
    "btl4-35b-iq2": "btl4-35b",
    "gemma4-12b": "gemma4-12b",
    "gemma4-e2b": "gemma4-e2b",
    "gemma4-e4b": "gemma4-e4b",
    "granite4.2-3b": "granite4.2-3b",
    "lfm2.5-1.2b-instruct": "lfm2.5-1.2b",
    "lfm2.5-2.6b": "lfm2.5-2.6b",
    "lfm2.5-8b-a1b-control": "lfm2.5-8b-a1b",
    "lfm2.5-8b-a1b-dspark": "lfm2.5-8b-a1b",
    "minicpm5-2b-q4-bench": "minicpm5-2b",
    "minicpm5-2b-q4-bench-rp": "minicpm5-2b",
    "minicpm5-2b-q8-bench": "minicpm5-2b",
    "minicpm5-2b-q8-bench-rp105": "minicpm5-2b",
    "minicpm5-2b-q8-bench-rp110": "minicpm5-2b",
    "minicpm5-2b-q8-bench-rp115": "minicpm5-2b",
    "minicpm5-2b-q8-bench-rp120": "minicpm5-2b",
    "muse-glimmer-30b": "muse-glimmer-30b",
    "nemotron-3.5-lightning": "nemotron-3.5",
    "ornith-35b": "ornith-35b",
    "qwen3.6-35b-a3b-bench": "qwen3.6-35b-a3b",
    "qwen3.8-27b": "qwen3.8-27b",
    "qwen3.8-27b-ad": "qwen3.8-27b",
    "qwen3.8-27b-mtp": "qwen3.8-27b",
    "qwen3.8-27b-mtp-low": "qwen3.8-27b",
    "qwen3.8-27b-mtp-medium": "qwen3.8-27b",
    "qwen3.8-27b-mtp-nothink": "qwen3.8-27b",
    "qwen3.8-27b-mtp-xhigh": "qwen3.8-27b",
    "qwen3.8-27b-q4-low": "qwen3.8-27b",
    "qwen3.8-27b-q4-xhigh": "qwen3.8-27b",
    "qwen3.8-35b-a3b": "qwen3.8-35b-a3b",
    "spark-x2.5-4b-bench": "spark-x2.5-4b",
    "spark-x2.5-4b-bench-rp105": "spark-x2.5-4b",
    "spark-x2.5-4b-bench-rp110": "spark-x2.5-4b",
    "spark-x2.5-4b-bench-rp115": "spark-x2.5-4b",
    "spark-x2.5-4b-bench-rp120": "spark-x2.5-4b",
    "spark-x2.5-4b-bench-t07": "spark-x2.5-4b",
    "spark-x2.5-4b-bench-topk20": "spark-x2.5-4b",
}
# fmt: on


def _skip(task: dict) -> bool:
    response = task.get("response") or ""
    return bool(
        task.get("timed_out")
        or task.get("loop_killed")
        or task.get("length_exceeded")
        or task.get("harness_error")
        or task.get("error")
        or task.get("done_reason") == "length"
        or ("</think>" in response and "<think>" not in response.split("</think>")[0])
    )


def _key(program: str) -> str:
    """Identity of a program: trailing spaces and blank lines don't count."""
    return "\n".join(line.rstrip() for line in program.splitlines() if line.strip())


def collect(results: Path) -> dict[tuple[str, str], dict]:
    """Return distinct candidate programs keyed by (task_id, program key)."""
    problems = ep._problems("humaneval")
    pool: dict[tuple[str, str], dict] = {}
    for path in sorted(results.glob("*/results.json")):
        if path.parent.name in EXCLUDED_RUNS:
            continue
        try:
            jobs = json.loads(path.read_text(encoding="utf-8"))
        except (json.JSONDecodeError, UnicodeDecodeError):
            continue
        for job in jobs if isinstance(jobs, list) else []:
            model = job.get("model")
            if (
                job.get("benchmark") != "humaneval-plus"
                or job.get("harness") != "direct"
                or model not in MODELS
            ):
                continue
            for task in job.get("tasks", []):
                task_id = task.get("task_id")
                if task_id not in problems or _skip(task):
                    continue
                if not ep._extract_code(task.get("response") or "").strip():
                    continue
                program = ep._human_solution(problems[task_id], task["response"])
                entry = pool.setdefault(
                    (task_id, _key(program)),
                    {"task_id": task_id, "program": program, "models": set()},
                )
                entry["models"].add(model)
    return pool


def _check(task_id: str, program: str, **limits: float) -> tuple[bool, bool]:
    problem = ep._problems("humaneval")[task_id]
    result = ep._evalplus_api()[4](
        "humaneval",
        completion_id=0,
        problem=problem,
        solution=program,
        expected_output=ep._expected_output("humaneval", task_id),
        fast_check=True,
        **limits,
    )
    return result["base"][0] == "pass", result["plus"][0] == "pass"


def label(entry: dict) -> dict:
    """Execute one program and record its label, or why it is unusable."""
    try:
        compile(entry["program"], "<candidate>", "exec")
    except (SyntaxError, ValueError):
        return {**entry, "status": "no_compile"}
    base, plus = _check(entry["task_id"], entry["program"])
    if base and plus:
        return {**entry, "status": "pass", "base_pass": True}
    if all(_check(entry["task_id"], entry["program"], **GENEROUS)):
        return {**entry, "status": "slow_only"}
    return {**entry, "status": "fail", "base_pass": base}


def _pick(
    candidates: dict[str, list[dict]],
    quota: dict[str, int],
    family_used: Counter,
    want: int,
    cap: dict[str, int] | None = None,
) -> list[dict]:
    """Round-robin over tasks, one program per task per round, within caps.

    Without ``cap`` every family may reach ``FAMILY_CAP`` and each task's queue
    is taken in order. With ``cap`` each family has its own limit and a task
    offers the family furthest below its limit first.
    """

    def room(entry: dict) -> int:
        limit = FAMILY_CAP if cap is None else cap.get(entry["family"], 0)
        return limit - family_used[entry["family"]]

    chosen: list[dict] = []
    while len(chosen) < want:
        progressed = False
        for task_id in sorted(candidates):
            queue = candidates[task_id]
            eligible = [e for e in queue if room(e) > 0]
            if quota[task_id] <= 0 or not eligible:
                continue
            entry = eligible[0] if cap is None else max(eligible, key=room)
            queue.remove(entry)
            family_used[entry["family"]] += 1
            quota[task_id] -= 1
            chosen.append(entry)
            progressed = True
            if len(chosen) == want:
                break
        if not progressed:
            break
    return chosen


def select(labelled: list[dict]) -> tuple[list[dict], list[dict]]:
    rng = random.Random(SEED)
    by_task: dict[str, dict[str, list[dict]]] = defaultdict(
        lambda: {"fail": [], "pass": []}
    )
    for entry in sorted(labelled, key=lambda e: (e["task_id"], e["program"])):
        if entry["status"] in ("pass", "fail"):
            entry["model"] = min(entry["models"])
            entry["family"] = MODELS[entry["model"]]
            by_task[entry["task_id"]][entry["status"]].append(entry)
    for sides in by_task.values():
        for side in sides.values():
            rng.shuffle(side)
        sides["fail"].sort(key=lambda e: not e["base_pass"])  # near misses first

    fails = _pick(
        {t: s["fail"] for t, s in by_task.items() if s["fail"]},
        defaultdict(lambda: PER_TASK),
        Counter(),
        PER_SIDE,
    )
    # Passing programs mirror the failing side: same tasks first, and per
    # family no more than that family failed, so neither the task nor the
    # model's coding style predicts the label. The global cap is a last resort.
    per_task_fails = Counter(e["task_id"] for e in fails)
    fail_families = Counter(e["family"] for e in fails)
    pass_used: Counter = Counter()
    passes = _pick(
        {t: by_task[t]["pass"] for t in per_task_fails},
        defaultdict(int, per_task_fails),
        pass_used,
        PER_SIDE,
        cap=fail_families,
    )
    quota = defaultdict(
        lambda: PER_TASK,
        {t: PER_TASK - sum(e["task_id"] == t for e in passes) for t in by_task},
    )
    pass_queues = {t: s["pass"] for t, s in by_task.items()}
    passes += _pick(
        pass_queues, quota, pass_used, PER_SIDE - len(passes), cap=fail_families
    )
    passes += _pick(pass_queues, quota, pass_used, PER_SIDE - len(passes))
    return fails, passes


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    parser.add_argument("--results", type=Path, default=ROOT / "results")
    parser.add_argument("--output", type=Path, default=OUTPUT)
    parser.add_argument("--workers", type=int, default=max(1, os.cpu_count() // 2))
    parser.add_argument(
        "--label-cache",
        type=Path,
        help="JSON file of earlier labels, reused and updated (keep it out of git)",
    )
    args = parser.parse_args()

    pool = collect(args.results)
    print(f"{len(pool)} distinct programs over {len({t for t, _ in pool})} tasks")
    cache: dict[str, dict] = {}
    if args.label_cache and args.label_cache.exists():
        cache = json.loads(args.label_cache.read_text(encoding="utf-8"))
    labelled, todo = [], []
    for (task_id, key), entry in pool.items():
        hit = cache.get(f"{task_id}\n{key}")
        if hit:
            labelled.append({**entry, **hit})
        else:
            todo.append(entry)
    for task_id in sorted({e["task_id"] for e in todo}):
        ep._expected_output("humaneval", task_id)

    with ProcessPoolExecutor(args.workers) as executor:
        for done, entry in enumerate(executor.map(label, todo, chunksize=8), 1):
            labelled.append(entry)
            if done % 250 == 0:
                print(f"  labelled {done}/{len(todo)}", flush=True)
    print("labels:", dict(Counter(e["status"] for e in labelled)))
    if args.label_cache:
        for entry in labelled:
            cache[f"{entry['task_id']}\n{_key(entry['program'])}"] = {
                k: entry[k] for k in ("status", "base_pass") if k in entry
            }
        args.label_cache.write_text(json.dumps(cache), encoding="utf-8")

    fails, passes = select(labelled)
    if len(fails) < PER_SIDE or len(passes) < PER_SIDE:
        raise SystemExit(f"only {len(fails)} fail / {len(passes)} pass selectable")

    rng = random.Random(SEED)
    rng.shuffle(fails)
    rng.shuffle(passes)
    evaluator = f"evalplus=={version('evalplus')} base+plus, fast_check"
    problems = ep._problems("humaneval")
    with open(args.output, "w", encoding="utf-8") as out:
        for index, entry in enumerate(
            e for pair in zip(fails, passes, strict=True) for e in pair
        ):
            row = {
                "id": f"code-verifier/{index:03d}",
                "task_id": entry["task_id"],
                "entry_point": problems[entry["task_id"]]["entry_point"],
                "prompt": problems[entry["task_id"]]["prompt"],
                "solution": entry["program"],
                "passes": entry["status"] == "pass",
                "model": entry["model"],
                "version": DATASET_VERSION,
                "evaluator": evaluator,
            }
            out.write(json.dumps(row, ensure_ascii=False) + "\n")

    chosen = fails + passes
    print(f"wrote {len(chosen)} rows to {args.output}")
    print("near-miss fails:", sum(e["base_pass"] for e in fails))
    print("tasks:", len({e["task_id"] for e in chosen}))
    print("families (fail/pass):")
    fail_fam = Counter(e["family"] for e in fails)
    pass_fam = Counter(e["family"] for e in passes)
    for family in sorted(set(fail_fam) | set(pass_fam)):
        print(f"  {family:20} {fail_fam[family]:4} {pass_fam[family]:4}")


if __name__ == "__main__":
    main()