#!/usr/bin/env python3
"""RipBench binary classification evaluator (framework-agnostic).

HOW TO USE (no CLI args - edit CONFIG below, then: python evaluate_classification.py)
  1. Point PRED_DIR at a predictions/ folder (predict_ultralytics.py writes
     one next to the checkpoints) of <stem>_preds_val.json / <stem>_preds_test.json
     files (created by predict_ultralytics.py; each is a dict
     {image basename: P(rip)}). Only stems containing _cls_ are evaluated -
     a mixed folder is fine. Single model: PRED_DIR=None + PRED_VAL/PRED_TEST.
  2. Run (numpy only). One TSV row per model x split appends to
     eval/results/classification_eval.tsv (Sheets-ready).

PROTOCOL: the P(rip) decision threshold is selected PER MODEL on val (best
F2; rip = positive class - missing a rip is the costly error), frozen,
applied to test. Test-only: USE_VAL_SELECTION=False + FIXED_THRESHOLD.
AUROC and AP are threshold-free (computed from raw probabilities).
"""
import json
import os
_RIPBENCH_ROOT = os.environ.get("RIPBENCH_ROOT", os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..")))  # release root (env RIPBENCH_ROOT overrides)
from datetime import datetime

import numpy as np

# --- configuration -----------------------------------------------------------
DATASET_ROOT = _RIPBENCH_ROOT
# EITHER a folder of prediction files (batch mode) ...
PRED_DIR = "/path/to/best_models/predictions"  # None -> use the single pair below
TASK_TOKEN = "_cls_"  # stems must contain this; "" = take every pair in PRED_DIR
# ... OR a single pair:
PRED_VAL = "/path/to/<model>_preds_val.json"  # ignored if USE_VAL_SELECTION = False
PRED_TEST = "/path/to/<model>_preds_test.json"

USE_VAL_SELECTION = True
FIXED_THRESHOLD = 0.5  # used only when USE_VAL_SELECTION = False

THRESHOLD_SWEEP = [round(x / 100, 2) for x in range(1, 96)]  # 0.01..0.95 step 0.01 (same grid as detection)

MODEL_TAG = None  # None = derived from PRED_TEST filename
OUT_TSV = os.path.join(os.path.dirname(os.path.abspath(__file__)), "results", "classification_eval.tsv")
# ------------------------------------------------------------------------------

HEADER = ("timestamp\tmodel\ttask\tsplit\tselected_thr\tselected_on"
          "\tn_images\tn_rip\tn_no_rip\tAUROC\tAP"
          "\taccuracy\tP\tR\tF1\tF2\tspecificity\tTP\tFP\tFN\tTN\n")


def f_beta(p, r, beta):
    denom = beta * beta * p + r
    return (1 + beta * beta) * p * r / denom if denom > 0 else 0.0


def load_gt(split):
    path = os.path.join(DATASET_ROOT, "labels", "classification", f"{split}.txt")
    gt = {}
    for line in open(path).read().splitlines():
        if not line:
            continue
        image_rel, label = line.rsplit(" ", 1)
        gt[os.path.basename(image_rel)] = int(label)
    return gt


def load_preds(path, gt):
    with open(path) as f:
        preds = json.load(f)
    assert isinstance(preds, dict), f"{path}: expected dict basename -> P(rip)"
    missing = set(gt) - set(preds)
    assert not missing, f"{path}: predictions missing for {len(missing)} GT images, e.g. {sorted(missing)[:3]}"
    y = np.array([gt[k] for k in sorted(gt)], dtype=int)
    s = np.array([float(preds[k]) for k in sorted(gt)], dtype=float)
    return y, s


def counts_at(y, s, thr):
    pred = s >= thr
    tp = int(((pred == 1) & (y == 1)).sum())
    fp = int(((pred == 1) & (y == 0)).sum())
    fn = int(((pred == 0) & (y == 1)).sum())
    tn = int(((pred == 0) & (y == 0)).sum())
    return tp, fp, fn, tn


def metrics_at(y, s, thr):
    tp, fp, fn, tn = counts_at(y, s, thr)
    p = tp / (tp + fp) if tp + fp else 0.0
    r = tp / (tp + fn) if tp + fn else 0.0
    return {"TP": tp, "FP": fp, "FN": fn, "TN": tn, "P": p, "R": r,
            "F1": f_beta(p, r, 1.0), "F2": f_beta(p, r, 2.0),
            "acc": (tp + tn) / len(y), "spec": tn / (tn + fp) if tn + fp else 0.0}


def auroc(y, s):
    """Rank-based AUROC (equals Mann-Whitney U / (n_pos * n_neg)); ties get
    average ranks."""
    n_pos, n_neg = int((y == 1).sum()), int((y == 0).sum())
    if n_pos == 0 or n_neg == 0:
        return float("nan")
    order = np.argsort(s, kind="mergesort")
    ranks = np.empty(len(s), dtype=float)
    sorted_s = s[order]
    i = 0
    while i < len(s):
        j = i
        while j + 1 < len(s) and sorted_s[j + 1] == sorted_s[i]:
            j += 1
        ranks[order[i:j + 1]] = (i + j) / 2 + 1  # average rank, 1-based
        i = j + 1
    return float((ranks[y == 1].sum() - n_pos * (n_pos + 1) / 2) / (n_pos * n_neg))


def average_precision(y, s):
    """Step-wise area under the precision-recall curve."""
    order = np.argsort(-s, kind="mergesort")
    y_sorted = y[order]
    tp_cum = np.cumsum(y_sorted)
    n_pos = int((y == 1).sum())
    if n_pos == 0:
        return float("nan")
    precision = tp_cum / np.arange(1, len(y) + 1)
    recall = tp_cum / n_pos
    # sum precision at each new TP (step integration)
    return float(precision[y_sorted == 1].sum() / n_pos)


def append_row(row):
    os.makedirs(os.path.dirname(OUT_TSV), exist_ok=True)
    write_header = not os.path.isfile(OUT_TSV)
    with open(OUT_TSV, "a") as f:
        if write_header:
            f.write(HEADER)
        f.write("\t".join(str(x) for x in row) + "\n")


def make_row(model, split, thr, selected_on, y, s):
    m = metrics_at(y, s, thr)
    return [datetime.now().strftime("%Y-%m-%d %H:%M"), model, "classification", split,
            f"{thr:.2f}", selected_on, len(y), int((y == 1).sum()), int((y == 0).sum()),
            f"{auroc(y, s):.6f}", f"{average_precision(y, s):.6f}",
            f"{m['acc']:.6f}", f"{m['P']:.6f}", f"{m['R']:.6f}",
            f"{m['F1']:.6f}", f"{m['F2']:.6f}", f"{m['spec']:.6f}",
            m["TP"], m["FP"], m["FN"], m["TN"]]


def evaluate_pair(gt_val, gt_test, pred_val, pred_test, model):
    if USE_VAL_SELECTION:
        y_v, s_v = load_preds(pred_val, gt_val)
        sweep = [(t, metrics_at(y_v, s_v, t)) for t in THRESHOLD_SWEEP]
        best_thr, _ = max(sweep, key=lambda x: (x[1]["F2"], x[1]["R"], x[1]["P"], x[0]))
        selected_on = "val"
        print(f"[val] {model}: selected threshold={best_thr:.2f}")
        append_row(make_row(model, "val", best_thr, selected_on, y_v, s_v))
    else:
        best_thr = FIXED_THRESHOLD
        selected_on = "fixed"

    y_t, s_t = load_preds(pred_test, gt_test)
    append_row(make_row(model, "test", best_thr, selected_on, y_t, s_t))
    m = metrics_at(y_t, s_t, best_thr)
    print(f"[test] {model}: thr={best_thr:.2f} ({selected_on})  acc={m['acc']:.4f}  "
          f"P={m['P']:.4f} R={m['R']:.4f} F2={m['F2']:.4f}  "
          f"TP/FP/FN/TN={m['TP']}/{m['FP']}/{m['FN']}/{m['TN']}  "
          f"AUROC={auroc(y_t, s_t):.4f}\n")


def discover_pairs(pred_dir):
    for f in sorted(os.listdir(pred_dir)):
        if not f.endswith("_preds_test.json"):
            continue
        stem = f[: -len("_preds_test.json")]
        if TASK_TOKEN and TASK_TOKEN not in stem:
            continue
        val = os.path.join(pred_dir, stem + "_preds_val.json")
        yield stem, (val if os.path.isfile(val) else None), os.path.join(pred_dir, f)


def main():
    gt_val = load_gt("val") if USE_VAL_SELECTION else None
    gt_test = load_gt("test")

    if PRED_DIR:
        pairs = list(discover_pairs(PRED_DIR))
        print(f"batch mode: {len(pairs)} model(s) in {PRED_DIR}\n")
        failed = []
        for stem, pred_val, pred_test in pairs:
            if USE_VAL_SELECTION and pred_val is None:
                print(f"SKIP {stem}: no _preds_val.json (needed for threshold selection)")
                continue
            try:
                evaluate_pair(gt_val, gt_test, pred_val, pred_test, stem)
            except Exception as e:  # keep the batch going
                failed.append((stem, repr(e)))
                print(f"ERROR {stem}: {e!r}")
        print(f"done: {len(pairs) - len(failed)}/{len(pairs)} ok -> {OUT_TSV}")
        for stem, err in failed:
            print(f"  FAILED {stem}: {err}")
    else:
        model = MODEL_TAG or os.path.splitext(os.path.basename(PRED_TEST))[0]
        evaluate_pair(gt_val, gt_test, PRED_VAL, PRED_TEST, model)
        print(f"rows appended to {OUT_TSV}")


if __name__ == "__main__":
    main()