from __future__ import annotations

from pathlib import Path

import numpy as np
import pandas as pd
from sklearn.metrics import (
    average_precision_score,
    brier_score_loss,
    precision_recall_curve,
    roc_auc_score,
)

BUDGETS = (.10, .15, .20, .25)

REFERENCE_COLUMNS = {
    "shared": ("shared_results_dir", "residual_moe_shared"),
    "suite7": ("suite7_results_dir", "residual_moe_shared_private"),
    "suite8": ("suite8_results_dir", "residual_moe_true_specialist"),
    "suite9_candidate": ("suite9_results_dir", "residual_moe_competitive_candidate"),
    "suite9_final": ("suite9_results_dir", "residual_moe_competitive_final"),
    "suite10_candidate": ("suite10_results_dir", "semantic_specialist_candidate"),
    "suite10_final": ("suite10_results_dir", "semantic_specialist_final"),
    "suite11_candidate": ("suite11_results_dir", "opportunity_latent_candidate"),
    "suite11_final": ("suite11_results_dir", "opportunity_latent_final"),
    "suite12": ("suite12_results_dir", "suite12_collaborative_evidence_moe"),
    "suite13": ("suite13_results_dir", "suite13_committee_preserving_collaborative_moe"),
    "suite14": ("suite14_results_dir", "suite14_authority_safe_final"),
    "suite16": ("suite16_results_dir", "suite16_hgb_final"),
    "suite17": ("suite17_results_dir", "suite17_hgb_final"),
    "suite18": ("suite18_results_dir", "suite18_hgb_final"),
    "suite20_transformer": ("suite20_results_dir", "suite20_transformer"),
    "suite20_gru": ("suite20_results_dir", "suite20_gru"),
    "suite20_flat": ("suite20_results_dir", "suite20_flat"),
}


def safe_ap(y, p):
    y = np.asarray(y, int)
    return float(average_precision_score(y, p)) if np.unique(y).size > 1 else np.nan


def safe_auc(y, p):
    y = np.asarray(y, int)
    return float(roc_auc_score(y, p)) if np.unique(y).size > 1 else np.nan


def warn_by_rate(score, rate):
    score = np.asarray(score, float)
    n = len(score)
    k = max(0, min(n, int(round(float(rate) * n))))
    pred = np.zeros(n, np.int8)
    if k:
        pred[np.argsort(-score, kind="mergesort")[:k]] = 1
    return pred


def classification_metrics(y, pred, beta=2.0):
    y = np.asarray(y, int)
    pred = np.asarray(pred, int)
    tp = int(((y == 1) & (pred == 1)).sum())
    fp = int(((y == 0) & (pred == 1)).sum())
    fn = int(((y == 1) & (pred == 0)).sum())
    tn = int(((y == 0) & (pred == 0)).sum())
    p = tp / max(tp + fp, 1)
    r = tp / max(tp + fn, 1)
    f1 = 2 * p * r / max(p + r, 1e-12)
    b2 = beta * beta
    fbeta = (1 + b2) * p * r / max(b2 * p + r, 1e-12)
    return {
        "tp": tp, "fp": fp, "fn": fn, "tn": tn,
        "precision": p, "recall": r, "f1": f1, "fbeta": fbeta,
        "accuracy": (tp + tn) / max(len(y), 1), "flag_rate": float(pred.mean()),
    }


def budget_metrics(y, score, rate=.20, beta=2.0):
    return classification_metrics(y, warn_by_rate(score, rate), beta)


def expected_calibration_error(y, score, bins=10):
    y = np.asarray(y, int)
    score = np.clip(np.asarray(score, float), 0, 1)
    edges = np.linspace(0, 1, int(bins) + 1)
    total = max(len(y), 1)
    ece = 0.0
    for i in range(len(edges) - 1):
        if i == len(edges) - 2:
            m = (score >= edges[i]) & (score <= edges[i + 1])
        else:
            m = (score >= edges[i]) & (score < edges[i + 1])
        if m.any():
            ece += (m.sum() / total) * abs(float(score[m].mean()) - float(y[m].mean()))
    return float(ece)


def metric_row(fold, faculty, model, y, score, beta=2.0):
    y = np.asarray(y, int)
    score = np.asarray(score, float)
    row = {
        "fold": int(fold), "faculty": faculty, "model": model,
        "rows": len(y), "failures": int(y.sum()), "prevalence": float(y.mean()),
        "ap": safe_ap(y, score), "auc": safe_auc(y, score),
        "brier": float(brier_score_loss(y, np.clip(score, 0, 1))),
        "ece10": expected_calibration_error(y, score, 10),
        "mean_score": float(np.mean(score)),
        "calibration_gap": float(np.mean(score) - np.mean(y)),
    }
    for b in BUDGETS:
        z = budget_metrics(y, score, b, beta)
        tag = int(round(100 * b))
        for k in ["precision", "recall", "f1", "fbeta", "flag_rate"]:
            row[f"{k}_at_{tag}"] = z[k]
    return row


def _optional_scores(root, fold, faculty, column, y):
    if not root:
        return None
    p = Path(root) / f"fold_{fold}" / f"{faculty}_scores.csv"
    if not p.exists():
        return None
    df = pd.read_csv(p)
    if column not in df:
        return None
    if "actual" in df:
        actual = df.actual.to_numpy(int)
        if len(actual) != len(y) or not np.array_equal(actual, np.asarray(y, int)):
            raise ValueError(f"Reference alignment mismatch: {p}")
    if len(df) != len(y):
        raise ValueError(f"Reference row mismatch: {p}")
    return df[column].to_numpy(float)


def _v2_score(root, fold, faculty, y):
    if not root:
        return None
    p = Path(root) / f"{faculty}_fold_{fold}_test_results.csv"
    if not p.exists():
        return None
    df = pd.read_csv(p)
    req = {"actual_failure_lt5", "failure_probability_lt5"}
    if not req.issubset(df.columns):
        return None
    if len(df) != len(y) or not np.array_equal(df.actual_failure_lt5.to_numpy(int), np.asarray(y, int)):
        raise ValueError(f"V2 alignment mismatch: {p}")
    return df.failure_probability_lt5.to_numpy(float)


def _council_score(root, fold, faculty, y):
    if not root:
        return None
    candidates = [
        Path(root) / f"{faculty}_fold_{fold}_scores.csv",
        Path(root) / f"fold_{fold}" / f"{faculty}_scores.csv",
    ]
    p = next((x for x in candidates if x.exists()), None)
    if p is None:
        return None
    df = pd.read_csv(p)
    score_col = "final" if "final" in df else ("competence_council" if "competence_council" in df else None)
    if score_col is None or "actual" not in df:
        return None
    if len(df) != len(y) or not np.array_equal(df.actual.to_numpy(int), np.asarray(y, int)):
        raise ValueError(f"Council alignment mismatch: {p}")
    return df[score_col].to_numpy(float)


def reference_scores(args, fold, faculty, y, committee):
    scores = {"committee": np.asarray(committee, float)}
    for label, (arg_name, column) in REFERENCE_COLUMNS.items():
        z = _optional_scores(getattr(args, arg_name, None), fold, faculty, column, y)
        if z is not None:
            scores[label] = z
    z = _v2_score(getattr(args, "v2_results_dir", None), fold, faculty, y)
    if z is not None:
        scores["v2"] = z
    z = _council_score(getattr(args, "council_results_dir", None), fold, faculty, y)
    if z is not None:
        scores["council"] = z
    return scores


def mean_fold_summary(metrics, folds):
    d = pd.DataFrame(metrics)
    d = d[d.fold.isin(list(folds))]
    rows = []
    for (faculty, model), g in d.groupby(["faculty", "model"]):
        row = {
            "faculty": faculty, "model": model, "folds": len(g),
            "rows": int(g.rows.sum()),
        }
        for c in [
            "ap", "auc", "brier", "ece10", "mean_score", "calibration_gap",
            "precision_at_20", "recall_at_20", "f1_at_20", "fbeta_at_20"
        ]:
            row[f"mean_fold_{c}"] = float(g[c].mean())
        rows.append(row)
    return pd.DataFrame(rows)


def macro_summary(meanf):
    rows = []
    for model, g in meanf.groupby("model"):
        row = {"model": model, "faculties": g.faculty.nunique()}
        for c in [
            "mean_fold_ap", "mean_fold_auc", "mean_fold_brier", "mean_fold_ece10", "mean_fold_mean_score", "mean_fold_calibration_gap",
            "mean_fold_precision_at_20", "mean_fold_recall_at_20", "mean_fold_f1_at_20", "mean_fold_fbeta_at_20"
        ]:
            row[c] = float(g[c].mean())
        rows.append(row)
    return pd.DataFrame(rows).sort_values("mean_fold_ap", ascending=False)


def head_to_head(meanf, candidate):
    a = meanf[meanf.model == candidate]
    rows = []
    for ref in sorted(set(meanf.model) - {candidate}):
        b = meanf[meanf.model == ref]
        z = a.merge(b, on="faculty", suffixes=("_cand", "_ref"))
        if not len(z):
            continue
        da = z.mean_fold_ap_cand - z.mean_fold_ap_ref
        df2 = z.mean_fold_fbeta_at_20_cand - z.mean_fold_fbeta_at_20_ref
        rows.append({
            "candidate": candidate, "reference": ref, "faculties": len(z),
            "candidate_macro_ap": float(z.mean_fold_ap_cand.mean()),
            "reference_macro_ap": float(z.mean_fold_ap_ref.mean()),
            "mean_delta_ap": float(da.mean()), "median_delta_ap": float(da.median()),
            "q25_delta_ap": float(da.quantile(.25)), "worst_delta_ap": float(da.min()),
            "ap_wins": int((da > 0).sum()), "ap_win_rate": float((da > 0).mean()),
            "mean_delta_f2": float(df2.mean()), "median_delta_f2": float(df2.median()),
            "worst_delta_f2": float(df2.min()), "f2_wins": int((df2 > 0).sum()),
            "f2_win_rate": float((df2 > 0).mean()),
        })
    return pd.DataFrame(rows)


def retention_diagnostics(fold, faculty, y, committee, candidate):
    y = np.asarray(y, int)
    q = np.asarray(committee, float)
    p = np.asarray(candidate, float)
    rq = pd.Series(q).rank(method="average").to_numpy(float)
    rp = pd.Series(p).rank(method="average").to_numpy(float)
    rank_corr = float(np.corrcoef(rq, rp)[0, 1]) if len(q) > 2 and np.std(rq) and np.std(rp) else np.nan
    k = max(1, int(round(.20 * len(y))))
    iq = set(np.argsort(-q, kind="mergesort")[:k].tolist())
    ip = set(np.argsort(-p, kind="mergesort")[:k].tolist())
    return {
        "fold": int(fold), "faculty": faculty, "rows": len(y),
        "committee_ap": safe_ap(y, q), "candidate_ap": safe_ap(y, p),
        "delta_ap": safe_ap(y, p) - safe_ap(y, q),
        "probability_mae": float(np.mean(np.abs(p - q))),
        "probability_mean_delta": float(np.mean(p - q)),
        "rank_corr": rank_corr,
        "top20_overlap": float(len(iq & ip) / max(k, 1)),
        "increase_fraction": float(np.mean(p > q + 1e-8)),
        "decrease_fraction": float(np.mean(p < q - 1e-8)),
        "failure_mean_delta": float(np.mean((p - q)[y == 1])) if (y == 1).any() else np.nan,
        "normal_mean_delta": float(np.mean((p - q)[y == 0])) if (y == 0).any() else np.nan,
    }


def residual_diagnostics(fold, faculty, y, authority, guard, correction_members, committee):
    y = np.asarray(y, int)
    a = np.asarray(authority, float)
    g = np.asarray(guard, float)
    c = np.asarray(correction_members, float).mean(1)
    q = np.asarray(committee, float)
    corr_q = float(np.corrcoef(a, q)[0, 1]) if len(a) > 2 and np.std(a) > 0 and np.std(q) > 0 else np.nan
    return {
        "fold": int(fold), "faculty": faculty, "rows": len(y),
        "authority_mean": float(a.mean()), "authority_median": float(np.median(a)),
        "authority_failure_mean": float(a[y == 1].mean()) if (y == 1).any() else np.nan,
        "authority_normal_mean": float(a[y == 0].mean()) if (y == 0).any() else np.nan,
        "authority_committee_corr": corr_q,
        "guard_mean": float(g.mean()),
        "correction_mean": float(c.mean()), "correction_abs_mean": float(np.abs(c).mean()),
        "correction_positive_fraction": float(np.mean(c > 1e-8)),
        "correction_negative_fraction": float(np.mean(c < -1e-8)),
        "failure_correction_mean": float(c[y == 1].mean()) if (y == 1).any() else np.nan,
        "normal_correction_mean": float(c[y == 0].mean()) if (y == 0).any() else np.nan,
        "failure_negative_correction_fraction": float(np.mean(c[y == 1] < -1e-8)) if (y == 1).any() else np.nan,
        "failure_positive_correction_fraction": float(np.mean(c[y == 1] > 1e-8)) if (y == 1).any() else np.nan,
        "normal_negative_correction_fraction": float(np.mean(c[y == 0] < -1e-8)) if (y == 0).any() else np.nan,
        "high_committee_guard_mean": float(g[q >= .5].mean()) if (q >= .5).any() else np.nan,
    }


def top_budget_transitions(y, committee, candidate, rate=.20):
    y = np.asarray(y, int)
    qc = warn_by_rate(committee, rate)
    pc = warn_by_rate(candidate, rate)
    positives = y == 1
    return {
        "rescued_failures": int((positives & (qc == 0) & (pc == 1)).sum()),
        "lost_failures": int((positives & (qc == 1) & (pc == 0)).sum()),
        "retained_failures": int((positives & (qc == 1) & (pc == 1)).sum()),
        "new_false_positives": int(((y == 0) & (qc == 0) & (pc == 1)).sum()),
        "removed_false_positives": int(((y == 0) & (qc == 1) & (pc == 0)).sum()),
    }


def uncertainty_diagnostics(fold, faculty, y, score, uncertainty):
    y = np.asarray(y, int)
    score = np.asarray(score, float)
    u = np.asarray(uncertainty, float)
    if len(u) == 0:
        return pd.DataFrame()
    q = pd.qcut(pd.Series(u), q=min(4, max(1, len(np.unique(u)))), labels=False, duplicates="drop")
    rows = []
    for bucket in sorted(pd.unique(q.dropna())):
        m = q.to_numpy() == bucket
        rows.append({
            "fold": int(fold), "faculty": faculty, "uncertainty_quartile": int(bucket),
            "rows": int(m.sum()), "mean_uncertainty": float(u[m].mean()),
            "prevalence": float(y[m].mean()), "ap": safe_ap(y[m], score[m]),
            "auc": safe_auc(y[m], score[m]), "mean_abs_error": float(np.abs(score[m] - y[m]).mean()),
        })
    return pd.DataFrame(rows)


def attention_diagnostics(fold, faculty, y, attention, mask, max_semesters):
    a = attention.mean(1) if attention.ndim == 3 else attention
    mask = np.asarray(mask, bool)
    y = np.asarray(y, int)
    rows = []
    for pos in range(max_semesters):
        valid = mask[:, pos]
        if not valid.any():
            continue
        for label, gm in [("all", valid), ("failure", valid & (y == 1)), ("normal", valid & (y == 0))]:
            if gm.any():
                rows.append({
                    "fold": int(fold), "faculty": faculty, "group": label,
                    "semester_position_oldest0": int(pos),
                    "mean_attention": float(a[gm, pos].mean()), "rows_with_position": int(gm.sum()),
                })
    return pd.DataFrame(rows)


def best_fbeta_threshold(y, score, beta=2.0):
    y = np.asarray(y, int)
    score = np.asarray(score, float)
    if np.unique(y).size < 2:
        return .5, 0.0, float(y.mean())
    precision, recall, thresholds = precision_recall_curve(y, score)
    if len(thresholds) == 0:
        return .5, 0.0, float(y.mean())
    p = precision[:-1]
    r = recall[:-1]
    b2 = beta * beta
    f = (1 + b2) * p * r / np.maximum(b2 * p + r, 1e-12)
    best = np.where(f == np.nanmax(f))[0]
    # Prefer the highest threshold among ties to avoid unnecessary warnings.
    i = int(best[-1])
    threshold = float(thresholds[i])
    pred = score >= threshold
    return threshold, float(f[i]), float(pred.mean())


def build_operational_evaluation(scores: pd.DataFrame, dev_folds, holdout_folds, beta=2.0):
    meta = {"fold", "faculty", "actual", "student_id", "course_id", "target_semester", "history_semesters"}
    model_cols = [c for c in scores.columns if c not in meta and not c.endswith("_uncertainty") and not c.endswith("_authority") and not c.endswith("_guard") and not c.endswith("_correction")]
    policies = []
    eval_rows = []
    decision_frames = []

    for faculty in sorted(scores.faculty.unique()):
        fs = scores[scores.faculty == faculty]
        for model in model_cols:
            dev = fs[fs.fold.isin(dev_folds) & fs[model].notna()]
            hold = fs[fs.fold.isin(holdout_folds) & fs[model].notna()]
            if not len(dev) or not len(hold):
                continue
            ydev = dev.actual.to_numpy(int)
            sdev = dev[model].to_numpy(float)
            threshold, dev_f2, flag_rate = best_fbeta_threshold(ydev, sdev, beta)
            dev_prev = float(ydev.mean())
            ratio = float(flag_rate / max(dev_prev, 1e-6))
            policies.append({
                "faculty": faculty, "model": model, "dev_rows": len(dev),
                "dev_prevalence": dev_prev, "threshold": threshold,
                "dev_f2": dev_f2, "dev_flag_rate": flag_rate, "warning_ratio": ratio,
            })
            for fold in holdout_folds:
                z = fs[(fs.fold == fold) & fs[model].notna()]
                if not len(z):
                    continue
                y = z.actual.to_numpy(int)
                s = z[model].to_numpy(float)
                fixed_pred = (s >= threshold).astype(np.int8)
                prev = fs[fs.fold == (fold - 1)]
                prev_prev = float(prev.actual.mean()) if len(prev) else dev_prev
                drift_rate = float(np.clip(ratio * prev_prev, 1e-4, .99))
                drift_pred = warn_by_rate(s, drift_rate)
                fixed = classification_metrics(y, fixed_pred, beta)
                drift = classification_metrics(y, drift_pred, beta)
                row = {
                    "faculty": faculty, "model": model, "fold": int(fold),
                    "rows": len(y), "prevalence": float(y.mean()),
                    "ap": safe_ap(y, s), "auc": safe_auc(y, s),
                    "threshold": threshold, "dev_warning_ratio": ratio,
                    "drift_rate": drift_rate,
                }
                row.update({f"fixed_{k}": v for k, v in fixed.items()})
                row.update({f"drift_{k}": v for k, v in drift.items()})
                eval_rows.append(row)
                d = z[["fold", "faculty", "actual", "student_id", "course_id"]].copy()
                d["model"] = model
                d["score"] = s
                d["warning_fixed"] = fixed_pred
                d["warning_drift"] = drift_pred
                decision_frames.append(d)

    return pd.DataFrame(policies), pd.DataFrame(eval_rows), (pd.concat(decision_frames, ignore_index=True) if decision_frames else pd.DataFrame())


def operational_macro(eval_df: pd.DataFrame):
    if eval_df is None or not len(eval_df):
        return pd.DataFrame()
    faculty_rows = []
    for (faculty, model), g in eval_df.groupby(["faculty", "model"]):
        row = {"faculty": faculty, "model": model, "folds": len(g)}
        for c in [
            "ap", "auc", "fixed_precision", "fixed_recall", "fixed_fbeta", "fixed_flag_rate",
            "drift_precision", "drift_recall", "drift_fbeta", "drift_flag_rate"
        ]:
            row[f"mean_{c}"] = float(g[c].mean())
        faculty_rows.append(row)
    fdf = pd.DataFrame(faculty_rows)
    rows = []
    for model, g in fdf.groupby("model"):
        row = {"model": model, "faculties": g.faculty.nunique()}
        for c in [x for x in fdf.columns if x.startswith("mean_")]:
            row[c] = float(g[c].mean())
        rows.append(row)
    return pd.DataFrame(rows).sort_values("mean_ap", ascending=False)


def pooled_confusions(decisions: pd.DataFrame):
    if decisions is None or not len(decisions):
        return pd.DataFrame()
    rows = []
    for (faculty, model), g in decisions.groupby(["faculty", "model"]):
        y = g.actual.to_numpy(int)
        for policy in ["fixed", "drift"]:
            m = classification_metrics(y, g[f"warning_{policy}"].to_numpy(int), 2.0)
            rows.append({"faculty": faculty, "model": model, "policy": policy, "rows": len(g), **m})
    return pd.DataFrame(rows)


def overall_pooled_confusions(decisions: pd.DataFrame):
    if decisions is None or not len(decisions):
        return pd.DataFrame()
    rows = []
    for model, g in decisions.groupby("model"):
        y = g.actual.to_numpy(int)
        for policy in ["fixed", "drift"]:
            m = classification_metrics(y, g[f"warning_{policy}"].to_numpy(int), 2.0)
            rows.append({"model": model, "policy": policy, "rows": len(g), **m})
    return pd.DataFrame(rows)


def print_confusion(title, row):
    if row is None:
        return
    print("\n" + title)
    print("-" * 76)
    print(f"  Actual / Predicted          Normal >=5     Failure <5")
    print("-" * 76)
    print(f"  Normal >=5                 {int(row['tn']):>10,}     {int(row['fp']):>10,}")
    print(f"  Failure <5                 {int(row['fn']):>10,}     {int(row['tp']):>10,}")
    print("-" * 76)
    print(
        f"  Precision={row['precision']:.4f} Recall={row['recall']:.4f} "
        f"F2={row['fbeta']:.4f} Flag={100*row['flag_rate']:.2f}%"
    )


def print_table(title, df, cols=None, max_rows=None):
    print("\n" + title)
    print("-" * min(190, max(80, len(title) + 4)))
    if df is None or not len(df):
        print("<empty>")
        return
    z = df if cols is None else df[[c for c in cols if c in df.columns]]
    if max_rows:
        z = z.head(int(max_rows))
    print(z.to_string(index=False, float_format=lambda x: f"{x:.4f}"))
