"""Run ChatMod Bench against a moderation model and print the scores.

Examples:
    python run_benchmark.py --model axo-native-small-preview
    python run_benchmark.py --model omni                      # needs OPENAI_API_KEY
    python run_benchmark.py --model qwen3guard-0.6b           # also 4b / 8b
    python run_benchmark.py --predictions my_model.jsonl      # bring your own predictions

A predictions file has one line per case:
    {"id": "cmb-chat-de-...", "flagged": true, "score": 0.93}
`score` is optional and only used for ROC-AUC.
"""

from __future__ import annotations

import argparse
import json
import os
import sys
import time
import urllib.error
import urllib.request
from collections import defaultdict
from pathlib import Path

HERE = Path(__file__).resolve().parent
QWEN3GUARD = {
    "qwen3guard-0.6b": "Qwen/Qwen3Guard-Gen-0.6B",
    "qwen3guard-4b": "Qwen/Qwen3Guard-Gen-4B",
    "qwen3guard-8b": "Qwen/Qwen3Guard-Gen-8B",
}


def load_cases() -> list[dict]:
    with (HERE / "test.jsonl").open(encoding="utf-8") as fh:
        return [json.loads(line) for line in fh if line.strip()]


def run_axo_native(cases: list[dict]) -> list[dict]:
    from huggingface_hub import snapshot_download

    path = snapshot_download("henny52/axo-native-small-preview")
    sys.path.insert(0, path)
    from axo_native import AxoNativeSmall, AxoNativeTokenizer

    model = AxoNativeSmall.from_pretrained(path)
    tokenizer = AxoNativeTokenizer.from_pretrained(path)
    out = []
    for start in range(0, len(cases), 64):
        batch = [c["text"] for c in cases[start : start + 64]]
        for r in model.predict_json(batch, tokenizer, level="medium", explain=False):
            out.append({"flagged": r.action != "allow", "score": r.score})
    return out


def run_omni(cases: list[dict]) -> list[dict]:
    key = os.environ.get("OPENAI_API_KEY")
    if not key:
        raise SystemExit("Set OPENAI_API_KEY to run omni-moderation.")
    out = []
    for start in range(0, len(cases), 16):
        body = json.dumps(
            {
                "model": "omni-moderation-latest",
                "input": [c["text"] for c in cases[start : start + 16]],
            }
        ).encode("utf-8")
        for attempt in range(6):
            req = urllib.request.Request(
                "https://api.openai.com/v1/moderations",
                data=body,
                method="POST",
                headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
            )
            try:
                with urllib.request.urlopen(req, timeout=90) as resp:
                    results = json.loads(resp.read().decode("utf-8"))["results"]
                break
            except urllib.error.HTTPError as err:
                if err.code not in {429, 500, 502, 503, 504} or attempt == 5:
                    raise
                time.sleep(2**attempt)
        for item in results:
            out.append(
                {"flagged": bool(item["flagged"]), "score": max(item["category_scores"].values())}
            )
    return out


def run_qwen3guard(name: str, cases: list[dict]) -> list[dict]:
    import torch
    from transformers import AutoModelForCausalLM, AutoTokenizer

    repo = QWEN3GUARD[name]
    tokenizer = AutoTokenizer.from_pretrained(repo)
    model = AutoModelForCausalLM.from_pretrained(repo, dtype="auto", device_map="auto")
    labels = {"Unsafe": 1.0, "Controversial": 0.5, "Safe": 0.0}
    out = []
    for i, case in enumerate(cases, 1):
        prompt = tokenizer.apply_chat_template(
            [{"role": "user", "content": case["text"]}],
            tokenize=False,
            add_generation_prompt=True,
        )
        inputs = tokenizer([prompt], return_tensors="pt").to(model.device)
        with torch.no_grad():
            generated = model.generate(**inputs, max_new_tokens=32, do_sample=False)
        answer = tokenizer.decode(
            generated[0][inputs.input_ids.shape[1] :], skip_special_tokens=True
        )
        verdict = next((label for label in labels if f"Safety: {label}" in answer), "Safe")
        out.append({"flagged": verdict != "Safe", "score": labels[verdict]})
        if i % 50 == 0:
            print(f"{i}/{len(cases)}", file=sys.stderr)
    return out


def load_predictions(path: Path, cases: list[dict]) -> list[dict]:
    preds = {}
    with path.open(encoding="utf-8") as fh:
        for line in fh:
            if line.strip():
                row = json.loads(line)
                preds[row["id"]] = row
    missing = [c["id"] for c in cases if c["id"] not in preds]
    if missing:
        raise SystemExit(f"{len(missing)} cases have no prediction, e.g. {missing[0]}")
    return [
        {
            "flagged": bool(preds[c["id"]]["flagged"]),
            "score": float(preds[c["id"]].get("score", preds[c["id"]]["flagged"])),
        }
        for c in cases
    ]


def roc_auc(labels: list[int], scores: list[float]) -> float | None:
    pos = [s for s, y in zip(scores, labels, strict=True) if y == 1]
    neg = [s for s, y in zip(scores, labels, strict=True) if y == 0]
    if not pos or not neg:
        return None
    wins = sum((p > n) + 0.5 * (p == n) for p in pos for n in neg)
    return wins / (len(pos) * len(neg))


def metrics(rows: list[tuple[dict, dict]]) -> dict:
    tp = sum(1 for c, p in rows if p["flagged"] and c["label"] == 1)
    tn = sum(1 for c, p in rows if not p["flagged"] and c["label"] == 0)
    fp = sum(1 for c, p in rows if p["flagged"] and c["label"] == 0)
    fn = sum(1 for c, p in rows if not p["flagged"] and c["label"] == 1)

    def f1(tp_: int, fp_: int, fn_: int) -> float:
        return 2 * tp_ / max(1, 2 * tp_ + fp_ + fn_)

    return {
        "n": len(rows),
        "accuracy": (tp + tn) / max(1, len(rows)),
        "macro_f1": (f1(tp, fp, fn) + f1(tn, fn, fp)) / 2,
        "false_positive_rate": fp / max(1, fp + tn),
        "false_negative_rate": fn / max(1, fn + tp),
        "roc_auc": roc_auc([c["label"] for c, _ in rows], [p["score"] for _, p in rows]),
    }


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    source = parser.add_mutually_exclusive_group(required=True)
    source.add_argument("--model", choices=["axo-native-small-preview", "omni", *QWEN3GUARD])
    source.add_argument("--predictions", type=Path)
    parser.add_argument("--out", type=Path, help="write per-case predictions as JSONL")
    parser.add_argument("--limit", type=int, help="only the first N cases (quick check)")
    args = parser.parse_args()

    cases = load_cases()
    if args.limit:
        cases = cases[: args.limit]
    if args.predictions:
        preds = load_predictions(args.predictions, cases)
    elif args.model == "axo-native-small-preview":
        preds = run_axo_native(cases)
    elif args.model == "omni":
        preds = run_omni(cases)
    else:
        preds = run_qwen3guard(args.model, cases)

    if args.out:
        with args.out.open("w", encoding="utf-8") as fh:
            for c, p in zip(cases, preds, strict=True):
                fh.write(json.dumps({"id": c["id"], **p}) + "\n")

    rows = list(zip(cases, preds, strict=True))
    groups: dict[str, list] = defaultdict(list)
    for c, p in rows:
        groups[f"{c['source']} {c['lang']}"].append((c, p))
    print(
        f"{'subset':16s} {'n':>4s} {'acc':>7s} {'macroF1':>8s} {'FPR':>7s} {'FNR':>7s} {'AUC':>6s}"
    )
    for name, items in [("all", rows), *sorted(groups.items())]:
        m = metrics(items)
        auc = f"{m['roc_auc']:.3f}" if m["roc_auc"] is not None else "  -  "
        print(
            f"{name:16s} {m['n']:4d} {m['accuracy']:7.1%} {m['macro_f1']:8.3f} "
            f"{m['false_positive_rate']:7.1%} {m['false_negative_rate']:7.1%} {auc:>6s}"
        )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())