"""Evaluate a model on ShadowBench through any OpenAI-compatible endpoint. Resumable: finished episodes are skipped.

  # OpenAI
  OPENAI_API_KEY=... uv run python scripts/run_eval.py --models gpt-6.1-sol --effort medium
  # OpenRouter (cost per response is read from the endpoint); label=endpoint_id keeps the leaderboard name
  OPENROUTER_API_KEY=... uv run python scripts/run_eval.py --base-url https://openrouter.ai/api/v1 \
      --api-key-env OPENROUTER_API_KEY --models claude-opus-5.5=anthropic/claude-opus-5.5 \
      --extra-body '{"reasoning": {"effort": "medium"}}'
  # an open model on a local vLLM or SGLang server
  uv run python scripts/run_eval.py --base-url http://localhost:8000/v1 --api-key-env NONE --models your-model

The leaderboard protocol is one episode on each of the 20 certified plates per model and reasoning effort.
Episodes go to <out>/<label>@<effort>/<task_id>/ (the layout of the published episodes); an episode that failed for
infrastructure reasons (timeout, endpoint error) is moved aside and retried on the next invocation. At the end the
script prints each model's mean score with a 95% bootstrap interval over plates, cost and time per episode,
comparable with the leaderboard.
"""
import os

os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")  # collision checks run in threads; one BLAS thread each

import argparse
import asyncio
import json
import statistics as st
import time
from pathlib import Path

import numpy as np

from shadowbench import tasks
from shadowbench.agent import Pricing, run_episode

ap = argparse.ArgumentParser()
ap.add_argument("--models", nargs="+", required=True, help="endpoint model ids, or label=endpoint_model_id")
ap.add_argument("--tasks", nargs="+", default=None, help="plates (default: all 20 certified plates)")
ap.add_argument("--out", default="runs")
ap.add_argument("--base-url", default=None, help="OpenAI-compatible base URL (default: OpenAI)")
ap.add_argument("--api-key-env", default="OPENAI_API_KEY", help="environment variable with the API key; NONE for none")
ap.add_argument("--concurrency", type=int, default=3)
ap.add_argument("--effort", default=None, help="reasoning_effort to send, e.g. medium (omitted if not given)")
ap.add_argument("--extra-body", default=None, help='JSON merged into each request, e.g. \'{"reasoning": {"effort": "high"}}\'')
ap.add_argument("--timeout", type=float, default=3600, help="seconds per episode")
ap.add_argument("--max-tokens", type=int, default=None)
ap.add_argument("--price-in", type=float, default=None, help="USD per 1M input tokens")
ap.add_argument("--price-out", type=float, default=None, help="USD per 1M output tokens")
ap.add_argument("--price-cached", type=float, default=None, help="USD per 1M cached input tokens")
ap.add_argument("--budget-usd", type=float, default=None, help="start no new episode beyond this total cost")
a = ap.parse_args()
setting = a.effort or "default"


def summarize(out_root: Path, labels: list[str]):
    print("\nmodel                       episodes  score [95% CI]          USD/episode  min/episode")
    for label in labels:
        res = [json.loads(p.read_text()) for p in sorted((out_root / f"{label}@{setting}").glob("*/result.json"))]
        res = [x for x in res if not x["failed"]]
        if not res:
            continue
        # scores as the report rounds them, plates in a fixed order
        s = np.array([round(x["final"]["score"], 2) for x in sorted(res, key=lambda x: x["task_id"])])
        rng = np.random.default_rng(20261105)
        b = s[rng.integers(0, len(s), (10000, len(s)))].mean(1) if len(s) > 1 else s
        costs = [x["usage"]["cost_usd"] for x in res if x["usage"]["cost_usd"] is not None]
        print(f"{label + '@' + setting:28s}{len(res):8d}  {s.mean():6.2f} [{np.percentile(b, 2.5):6.2f}, {np.percentile(b, 97.5):6.2f}]"
              f"   {('$%.3f' % st.mean(costs)) if costs else 'n/a':>10s}  {st.mean(x['seconds'] for x in res) / 60:10.1f}")


async def main():
    from openai import AsyncOpenAI

    key = "none" if a.api_key_env == "NONE" else os.environ[a.api_key_env]
    client = AsyncOpenAI(base_url=a.base_url, api_key=key, timeout=600, max_retries=4)
    pricing = Pricing(a.price_in, a.price_out, a.price_cached)
    extra = json.loads(a.extra_body) if a.extra_body else None
    sem = asyncio.Semaphore(a.concurrency)
    models = [tuple(m.split("=", 1)) if "=" in m else (m, m) for m in a.models]
    jobs = []
    for task_id in a.tasks or tasks():  # interleave models so that every model progresses at the same rate
        for label, mid in models:
            od = Path(a.out) / f"{label}@{setting}" / task_id
            if (od / "result.json").exists():
                continue
            jobs.append((label, mid, task_id, od))
    spent = {"usd": 0.0}

    async def one(label, mid, task_id, od):
        async with sem:
            if a.budget_usd is not None and spent["usd"] > a.budget_usd:
                print(f"budget reached, skipping {label} {task_id}", flush=True)
                return
            if od.exists():  # a partial episode from an interrupted run
                dst = od.parent / ".failed" / f"{task_id}_{int(time.time())}"
                dst.parent.mkdir(parents=True, exist_ok=True)
                od.rename(dst)
            t0 = time.time()
            try:
                r = await run_episode(client, mid, task_id, od, label=label, reasoning_effort=a.effort, extra_body=extra,
                                      pricing=pricing, timeout_s=a.timeout, max_tokens=a.max_tokens)
            except Exception as e:
                print(f"FAIL  {label} {task_id}: {type(e).__name__}: {e}", flush=True)
                return
            spent["usd"] += r["usage"]["cost_usd"] or 0.0
            cost = r["usage"]["cost_usd"]
            score = r["final"]["score"] if r["final"] else float("nan")
            print(f"done  {label} {task_id} score={score:.1f} calls={r['calls']} refused={r['refusals']} "
                  f"cost={'n/a' if cost is None else f'${cost:.3f}'} t={time.time() - t0:.0f}s", flush=True)
            if r["failed"]:
                dst = od.parent / ".failed" / f"{task_id}_{int(time.time())}"
                dst.parent.mkdir(parents=True, exist_ok=True)
                od.rename(dst)
                print(f"      {label} {task_id} failed ({r['status']}); moved to {dst}, will be retried", flush=True)

    print(f"{len(jobs)} episodes to run", flush=True)
    await asyncio.gather(*(one(*j) for j in jobs))
    summarize(Path(a.out), [label for label, _ in models])


asyncio.run(main())