#!/usr/bin/env python3
"""Evaluate MDU-RiskBench participant-level prediction JSONL."""

from __future__ import annotations

import argparse
import gzip
import json
import math
from collections import Counter
from pathlib import Path

ORDER = {
    "no_observed_risk": 0,
    "mild_risk": 1,
    "moderate_risk": 2,
    "high_risk": 3,
}
ABSTAIN = "insufficient_evidence"


def read_jsonl(path: Path):
    opener = gzip.open if path.suffix == ".gz" else open
    with opener(path, "rt", encoding="utf-8") as handle:
        for line in handle:
            if line.strip():
                yield json.loads(line)


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--gold", type=Path, required=True)
    parser.add_argument("--predictions", type=Path, required=True)
    parser.add_argument("--output", type=Path)
    args = parser.parse_args()

    gold = {
        row["sample_id"]: row["target_label"]["risk_level"]
        for row in read_jsonl(args.gold)
    }
    pred = {row["sample_id"]: row["risk_level"] for row in read_jsonl(args.predictions)}
    unknown = sorted(set(pred) - set(gold))
    if unknown:
        raise SystemExit(f"unknown prediction IDs: {unknown[:5]}")

    labels = list(ORDER)
    total = len(gold)
    covered = [(gold[sid], pred.get(sid)) for sid in gold if pred.get(sid) in ORDER]
    abstained = total - len(covered)
    exact = sum(actual == predicted for actual, predicted in covered)
    distances = [abs(ORDER[actual] - ORDER[predicted]) for actual, predicted in covered]
    squared = [value * value for value in distances]
    f1_values = []
    for label in labels:
        tp = sum(actual == label and predicted == label for actual, predicted in covered)
        fp = sum(actual != label and predicted == label for actual, predicted in covered)
        fn = sum(actual == label and predicted != label for actual, predicted in covered)
        precision = tp / (tp + fp) if tp + fp else 0.0
        recall = tp / (tp + fn) if tp + fn else 0.0
        f1_values.append(
            2 * precision * recall / (precision + recall) if precision + recall else 0.0
        )

    n = len(covered)
    report = {
        "gold_records": total,
        "prediction_records": len(pred),
        "covered_records": n,
        "abstained_or_missing_records": abstained,
        "coverage": n / total if total else 0.0,
        "selective_accuracy": exact / n if n else None,
        "selective_macro_f1": sum(f1_values) / len(f1_values) if n else None,
        "ordinal_mae": sum(distances) / n if n else None,
        "ordinal_rmse": math.sqrt(sum(squared) / n) if n else None,
        "prediction_distribution": dict(sorted(Counter(pred.values()).items())),
    }
    rendered = json.dumps(report, indent=2) + "\n"
    if args.output:
        args.output.write_text(rendered, encoding="utf-8")
    print(rendered, end="")


if __name__ == "__main__":
    main()