#!/usr/bin/env python3
"""Run and score the public Perch method-pair benchmarks.

Standard-library only. The command adapter is a persistent NDJSON process: it
receives one JSON object per line and returns one {"score": probability} per line.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import math
import os
from pathlib import Path
import shlex
import subprocess
import sys
import time
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen


DATASET_URL = {
    domain: f"https://huggingface.co/datasets/perchscan/{domain}-pairs-public/resolve/main/benchmark.jsonl"
    for domain in ("bug", "security")
}
QUESTION = {
    "bug": {
        "type": "noul",
        "instructions": "Does this method contain a concrete behavioral bug a caller can reach?",
        "criteria": {
            "true": "A reachable input makes the method violate its visible contract by returning a wrong result, leaving wrong state, or causing an unintended failure.",
            "false": "No concrete reachable case is supported by the method and supplied context. A possible-looking pattern alone is not enough.",
        },
    },
    "security": {
        "type": "noul",
        "instructions": "Does this method contain a concrete security vulnerability an attacker can reach?",
        "criteria": {
            "true": "A concrete path crosses a security boundary and can be exploited; name a reachable source, sensitive operation, and missing or incorrect protection.",
            "false": "No concrete reachable case is supported by the method and supplied context. A possible-looking pattern alone is not enough.",
        },
    },
}


def dataset_bytes(domain: str, path: Path | None) -> bytes:
    if path is not None:
        return (path / "benchmark.jsonl" if path.is_dir() else path).read_bytes()
    with urlopen(DATASET_URL[domain], timeout=120) as response:
        return response.read()


def load_pairs(domain: str, path: Path | None) -> tuple[list[dict], str]:
    raw = dataset_bytes(domain, path)
    pairs = [json.loads(line) for line in raw.splitlines() if line]
    if not pairs:
        raise ValueError("Benchmark contains no pairs")
    ids = set()
    for pair in pairs:
        if pair["domain"] != domain or pair["pair_id"] in ids:
            raise ValueError("Wrong domain or duplicate pair ID in benchmark")
        ids.add(pair["pair_id"])
        for role in ("before", "after"):
            if pair[role]["labels"][domain] not in (0, 1):
                raise ValueError(f"Invalid {domain} label for {pair['pair_id']}:{role}")
    return pairs, hashlib.sha256(raw).hexdigest()


def probability(value: object) -> float:
    if isinstance(value, bool):
        raise ValueError("Score must be a number, not a boolean")
    score = float(value)
    if not math.isfinite(score) or not 0 <= score <= 1:
        raise ValueError(f"Score must be a finite probability in [0, 1]: {value!r}")
    return score


def prediction_scores(path: Path, pairs: list[dict], domain: str,
                      require_complete: bool) -> dict[tuple[str, str], float]:
    expected = {(pair["pair_id"], role) for pair in pairs for role in ("before", "after")}
    scores = {}
    if not path.exists():
        if require_complete:
            raise FileNotFoundError(path)
        return scores
    for line in path.read_text().splitlines():
        if not line:
            continue
        row = json.loads(line)
        key = (row["pair_id"], row["role"])
        if key not in expected or key in scores or row.get("domain", domain) != domain:
            raise ValueError(f"Unexpected or duplicate prediction: {key}")
        scores[key] = probability(row["score"])
    if require_complete and scores.keys() != expected:
        missing = expected - scores.keys()
        raise ValueError(f"Predictions are missing {len(missing)} method sides")
    return scores


def average_precision(items: list[tuple[int, float]]) -> float:
    positives = sum(label for label, _ in items)
    if not positives:
        return 0.0
    ordered = sorted(items, key=lambda item: item[1], reverse=True)
    found = total = 0
    i = 0
    while i < len(ordered):
        j = i + 1
        while j < len(ordered) and ordered[j][1] == ordered[i][1]:
            j += 1
        positives_at_score = sum(label for label, _ in ordered[i:j])
        found += positives_at_score
        total += found / j * positives_at_score
        i = j
    return total / positives


def report(pairs: list[dict], scores: dict[tuple[str, str], float], domain: str,
           digest: str, model_revision: str, protocol_id: str,
           threshold: float) -> dict:
    items = [(pair[role]["labels"][domain], scores[pair["pair_id"], role])
             for pair in pairs for role in ("before", "after")]
    tp = sum(label == 1 and score >= threshold for label, score in items)
    fp = sum(label == 0 and score >= threshold for label, score in items)
    fn = sum(label == 1 and score < threshold for label, score in items)
    tn = sum(label == 0 and score < threshold for label, score in items)
    eligible = correct = ties = 0
    for pair in pairs:
        if pair["before"]["labels"][domain] == 1 and pair["after"]["labels"][domain] == 0:
            eligible += 1
            before, after = scores[pair["pair_id"], "before"], scores[pair["pair_id"], "after"]
            correct += before > after
            ties += before == after
    precision = tp / (tp + fp) if tp + fp else 0.0
    recall = tp / (tp + fn) if tp + fn else 0.0
    return {
        "domain": domain,
        "model_revision": model_revision,
        "protocol_id": protocol_id,
        "threshold": threshold,
        "benchmark_sha256": digest,
        "benchmark_pairs": len(pairs),
        "benchmark_methods": len(items),
        "average_precision": average_precision(items),
        "precision": precision,
        "recall": recall,
        "f1": 2 * tp / (2 * tp + fp + fn) if 2 * tp + fp + fn else 0.0,
        "false_positives_per_true_positive": fp / tp if tp else None,
        "confusion": {"tp": tp, "fp": fp, "tn": tn, "fn": fn},
        "vulnerable_or_buggy_before_above_fixed_after": {
            "correct": correct, "ties": ties, "eligible": eligible,
        },
    }


def jev_score(state: dict, domain: str, model: str, api_url: str) -> float:
    key = os.getenv("TYPESAFE_API_KEY") or os.getenv("PERCH_API_KEY")
    if not key:
        raise RuntimeError("Set TYPESAFE_API_KEY or PERCH_API_KEY to run Jev")
    name = "bug_any" if domain == "bug" else "security_any"
    payload = json.dumps({"model": model, "state": state, "questions": {name: QUESTION[domain]}}).encode()
    for attempt in range(4):
        request = Request(api_url, data=payload, method="POST", headers={
            "Authorization": f"Bearer {key}", "Content-Type": "application/json",
        })
        try:
            with urlopen(request, timeout=120) as response:
                answer = json.load(response)
            return probability(answer["answers"][name]["noul"])
        except HTTPError as exc:
            if exc.code not in (429, 500, 502, 503, 504) or attempt == 3:
                raise RuntimeError(f"Jev request failed with HTTP {exc.code}") from None
            delay = exc.headers.get("Retry-After")
            time.sleep(float(delay) if delay and delay.isdigit() else 2 ** attempt)
        except URLError:
            if attempt == 3:
                raise RuntimeError("Jev request failed after four network attempts") from None
            time.sleep(2 ** attempt)
    raise AssertionError("unreachable")


def run(args: argparse.Namespace) -> None:
    pairs, digest = load_pairs(args.domain, args.dataset)
    if args.scorer == "jev":
        revision, protocol = args.model_revision or "jev-1.13.0", "perch-broad-v1"
    else:
        if not args.command or not args.model_revision or not args.protocol_id:
            raise ValueError("Command scorer requires --command, --model-revision, and --protocol-id")
        revision, protocol = args.model_revision, args.protocol_id
    if args.predictions.exists():
        for line in args.predictions.read_text().splitlines():
            if line:
                row = json.loads(line)
                if row.get("model_revision") != revision or row.get("protocol_id") != protocol:
                    raise ValueError("Existing prediction file uses another model or protocol")
    existing = prediction_scores(args.predictions, pairs, args.domain, False)
    pending = [(pair, role) for pair in pairs for role in ("before", "after")
               if (pair["pair_id"], role) not in existing]
    if args.limit:
        pending = pending[:args.limit]
    command = None
    if args.scorer == "command" and pending:
        command = subprocess.Popen(shlex.split(args.command), stdin=subprocess.PIPE,
                                   stdout=subprocess.PIPE, text=True, bufsize=1)
    args.predictions.parent.mkdir(parents=True, exist_ok=True)
    try:
        with args.predictions.open("a") as output:
            for index, (pair, role) in enumerate(pending, 1):
                state = pair[role]["state"]
                if args.scorer == "jev":
                    score = jev_score(state, args.domain, revision, args.api_url)
                else:
                    request = {"domain": args.domain, "pair_id": pair["pair_id"], "role": role,
                               "language": pair.get("language"), "source": pair[role]["source"],
                               "state": state, "question": QUESTION[args.domain]}
                    assert command and command.stdin and command.stdout
                    command.stdin.write(json.dumps(request, ensure_ascii=False) + "\n")
                    command.stdin.flush()
                    line = command.stdout.readline()
                    if not line:
                        raise RuntimeError("Model adapter stopped before returning a score")
                    score = probability(json.loads(line)["score"])
                output.write(json.dumps({"domain": args.domain, "pair_id": pair["pair_id"],
                                         "role": role, "score": score, "model_revision": revision,
                                         "protocol_id": protocol}) + "\n")
                output.flush()
                if index % 100 == 0 or index == len(pending):
                    print(f"Scored {len(existing) + index}/{2 * len(pairs)} method sides", file=sys.stderr)
    finally:
        if command:
            command.stdin.close()
            try:
                command.wait(timeout=30)
            except subprocess.TimeoutExpired:
                command.terminate()
                command.wait(timeout=5)
            finally:
                command.stdout.close()
    scores = prediction_scores(args.predictions, pairs, args.domain, False)
    if len(scores) != 2 * len(pairs):
        print(f"Incomplete: {len(scores)}/{2 * len(pairs)} sides; rerun to resume", file=sys.stderr)
        return
    result = report(pairs, scores, args.domain, digest, revision, protocol, args.threshold)
    args.report.parent.mkdir(parents=True, exist_ok=True)
    args.report.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
    print(json.dumps(result, sort_keys=True))


def score_saved(args: argparse.Namespace) -> None:
    pairs, digest = load_pairs(args.domain, args.dataset)
    scores = prediction_scores(args.predictions, pairs, args.domain, True)
    first = json.loads(next(line for line in args.predictions.read_text().splitlines() if line))
    result = report(pairs, scores, args.domain, digest,
                    args.model_revision or first.get("model_revision", "unspecified"),
                    args.protocol_id or first.get("protocol_id", "unspecified"), args.threshold)
    args.report.parent.mkdir(parents=True, exist_ok=True)
    args.report.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
    print(json.dumps(result, sort_keys=True))


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    sub = parser.add_subparsers(dest="action", required=True)
    for name in ("run", "score"):
        command = sub.add_parser(name)
        command.add_argument("--domain", choices=("bug", "security"), required=True)
        command.add_argument("--dataset", type=Path, help="Local benchmark.jsonl; default downloads public pairs")
        command.add_argument("--predictions", type=Path, required=True)
        command.add_argument("--report", type=Path, required=True)
        command.add_argument("--threshold", type=float, default=0.5)
        command.add_argument("--model-revision")
        command.add_argument("--protocol-id")
        if name == "run":
            command.add_argument("--scorer", choices=("jev", "command"), required=True)
            command.add_argument("--command", help="Persistent NDJSON scorer command")
            command.add_argument("--api-url", default="https://api.typesafe.ai/v1/systemone")
            command.add_argument("--limit", type=int, default=0, help="Score at most N new sides, then resume later")
    args = parser.parse_args()
    if not 0 <= args.threshold <= 1:
        parser.error("--threshold must be in [0, 1]")
    if args.action == "run":
        if args.limit < 0:
            parser.error("--limit must be nonnegative")
        run(args)
    else:
        score_saved(args)


if __name__ == "__main__":
    main()