import csv
import json
from collections import Counter

VALID_LABELS = {"coherent", "tradeoff", "collapse_risk"}

LEVEL_MAP = {"low": 0, "medium": 1, "high": 2}
YESNO_MAP = {"no": 0, "yes": 1}

REQUIRED_GOLD_COLS = [
    "trial_id",
    "protocol_deviation",
    "staffing_drift",
    "adjudication_variance",
    "missingness_bias",
    "label",
]

def _norm(x) -> str:
    return str(x).strip().lower()

def _level(x, name: str) -> int:
    s = _norm(x)
    if s not in LEVEL_MAP:
        raise ValueError(f"Bad {name} value: {x}")
    return LEVEL_MAP[s]

def _yesno(x, name: str) -> int:
    s = _norm(x)
    if s not in YESNO_MAP:
        raise ValueError(f"Bad {name} value: {x}")
    return YESNO_MAP[s]

def _validate_gold_row(r: dict):
    for c in REQUIRED_GOLD_COLS:
        if c not in r:
            raise ValueError(f"Missing column: {c}")
    lab = str(r["label"]).strip()
    if lab not in VALID_LABELS:
        raise ValueError(f"Bad label: {r['label']}")

    _level(r["protocol_deviation"], "protocol_deviation")
    _yesno(r["staffing_drift"], "staffing_drift")
    _level(r["adjudication_variance"], "adjudication_variance")
    _level(r["missingness_bias"], "missingness_bias")

def _extract_pred_label(pred_row: dict) -> str:
    v = pred_row.get("label") or pred_row.get("prediction") or pred_row.get("output") or ""
    s = str(v).strip()
    if s in VALID_LABELS:
        return s
    if s.startswith("{") and s.endswith("}"):
        try:
            obj = json.loads(s)
            if isinstance(obj, dict) and "label" in obj:
                lab = str(obj["label"]).strip()
                if lab in VALID_LABELS:
                    return lab
        except Exception:
            pass
    return "invalid"

def rule_pred(g: dict) -> str:
    pdv = _level(g["protocol_deviation"], "protocol_deviation")
    sdr = _yesno(g["staffing_drift"], "staffing_drift")
    adv = _level(g["adjudication_variance"], "adjudication_variance")
    mss = _level(g["missingness_bias"], "missingness_bias")

    if pdv == 2 and adv == 2 and mss == 2 and sdr == 1:
        return "collapse_risk"

    # coherent allows one medium across the level fields, only if staffing drift is absent
    levels = [pdv, adv, mss]
    high_count = sum(v == 2 for v in levels)
    total = sum(levels)

    if sdr == 0 and high_count == 0 and total <= 1:
        return "coherent"

    return "tradeoff"

def risk_score(g: dict) -> float:
    pdv = _level(g["protocol_deviation"], "protocol_deviation")
    sdr = _yesno(g["staffing_drift"], "staffing_drift")
    adv = _level(g["adjudication_variance"], "adjudication_variance")
    mss = _level(g["missingness_bias"], "missingness_bias")

    raw = pdv + adv + mss + (2 * sdr)
    # max raw = 2+2+2+2 = 8
    return raw / 8.0

def run_scorer(preds_csv_path: str, gold_csv_path: str):
    with open(gold_csv_path, newline="", encoding="utf-8") as gf:
        gold_rows = list(csv.DictReader(gf))
    for r in gold_rows:
        _validate_gold_row(r)

    with open(preds_csv_path, newline="", encoding="utf-8") as pf:
        pred_rows = list(csv.DictReader(pf))

    pred_by_id = {}
    for r in pred_rows:
        pid = r.get("trial_id") or r.get("id")
        if pid is None:
            continue
        pred_by_id[str(pid).strip()] = r

    total = 0
    correct = 0
    confusion = Counter()
    errors = []
    missing_ids = []

    for g in gold_rows:
        gid = str(g["trial_id"]).strip()
        gold = str(g["label"]).strip()

        pr = pred_by_id.get(gid)
        if pr is None:
            pred = "missing"
            missing_ids.append(gid)
        else:
            pred = _extract_pred_label(pr)

        confusion[(gold, pred)] += 1

        if pred == gold:
            correct += 1
        else:
            errors.append({
                "trial_id": gid,
                "gold": gold,
                "pred": pred,
                "rule_pred": rule_pred(g),
                "risk_score": round(risk_score(g), 4),
            })

        total += 1

    report = {
        "n": total,
        "accuracy": (correct / total) if total else 0.0,
        "confusion": {f"{k[0]}->{k[1]}": v for k, v in confusion.items()},
        "avg_risk_score": round(sum(risk_score(r) for r in gold_rows) / max(1, len(gold_rows)), 4),
        "errors_sample": errors[:25],
        "missing_ids": missing_ids[:50],
    }
    return report

if __name__ == "__main__":
    import argparse
    p = argparse.ArgumentParser()
    p.add_argument("--preds_csv", required=True)
    p.add_argument("--gold_csv", required=True)
    args = p.parse_args()

    print(json.dumps(run_scorer(args.preds_csv, args.gold_csv), indent=2))