from __future__ import annotations

from pathlib import Path
from typing import Dict, Iterable, List

import numpy as np
import pandas as pd
from sklearn.metrics import average_precision_score, roc_auc_score, precision_recall_fscore_support, brier_score_loss

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"),
}


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 = int(round(float(rate) * n))
    k = max(0, min(n, k))
    pred = np.zeros(n, int)
    if k:
        pred[np.argsort(-score, kind="mergesort")[:k]] = 1
    return pred


def budget_metrics(y, score, rate=.20, beta=2.0):
    pred = warn_by_rate(score, rate)
    p, r, f1, _ = precision_recall_fscore_support(y, pred, average="binary", zero_division=0)
    b2 = beta * beta
    fbeta = (1 + b2) * p * r / max(b2 * p + r, 1e-12)
    return {"precision": p, "recall": r, "f1": f1, "fbeta": fbeta, "flag_rate": float(pred.mean())}


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))),
    }
    for b in BUDGETS:
        z = budget_metrics(y, score, b, beta)
        tag = int(round(100 * b))
        for k, v in z.items():
            row[f"{k}_at_{tag}"] = v
    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)
    if not {"actual_failure_lt5", "failure_probability_lt5"}.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)
    if not {"actual", "final"}.issubset(df.columns):
        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.final.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, holdout_folds):
    d = pd.DataFrame(metrics)
    d = d[d.fold.isin(list(holdout_folds))]
    rows = []
    for (faculty, model), g in d.groupby(["faculty", "model"]):
        row = {"faculty": faculty, "model": model, "holdout_folds": len(g), "holdout_rows": int(g.rows.sum())}
        for c in ["ap", "auc", "brier", "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_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()),
            "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 temporal_uplift_table(meanf, temporal_model="suite20_transformer", flat_model="suite20_flat"):
    a = meanf[meanf.model == temporal_model]
    b = meanf[meanf.model == flat_model]
    z = a.merge(b, on="faculty", suffixes=("_temporal", "_flat"))
    if not len(z):
        return pd.DataFrame()
    out = pd.DataFrame({
        "faculty": z.faculty,
        "temporal_ap": z.mean_fold_ap_temporal,
        "flat_ap": z.mean_fold_ap_flat,
        "delta_ap": z.mean_fold_ap_temporal - z.mean_fold_ap_flat,
        "temporal_auc": z.mean_fold_auc_temporal,
        "flat_auc": z.mean_fold_auc_flat,
        "delta_auc": z.mean_fold_auc_temporal - z.mean_fold_auc_flat,
        "temporal_f2": z.mean_fold_fbeta_at_20_temporal,
        "flat_f2": z.mean_fold_fbeta_at_20_flat,
        "delta_f2": z.mean_fold_fbeta_at_20_temporal - z.mean_fold_fbeta_at_20_flat,
    })
    return out.sort_values("delta_ap", ascending=False)


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):
    if attention.ndim == 3:
        a = attention.mean(1)
    else:
        a = attention
    mask = np.asarray(mask, bool)
    y = np.asarray(y, int)
    rows = []
    # Position 0 is the oldest retained semester, position T-1 the most recent.
    for pos in range(max_semesters):
        valid = mask[:, pos]
        if not valid.any():
            continue
        for label, group_mask in [("all", valid), ("failure", valid & (y == 1)), ("normal", valid & (y == 0))]:
            if group_mask.any():
                rows.append({
                    "fold": int(fold), "faculty": faculty, "group": label,
                    "semester_position_oldest0": int(pos),
                    "mean_attention": float(a[group_mask, pos].mean()),
                    "rows_with_position": int(group_mask.sum()),
                })
    return pd.DataFrame(rows)


def gate_diagnostics(fold, faculty, y, gate, history_length):
    y = np.asarray(y, int)
    gate = np.asarray(gate, float)
    h = np.asarray(history_length, float)
    corr = float(np.corrcoef(gate, h)[0, 1]) if len(gate) > 2 and np.std(gate) > 0 and np.std(h) > 0 else np.nan
    return {
        "fold": int(fold), "faculty": faculty, "rows": len(y),
        "gate_mean": float(gate.mean()), "gate_median": float(np.median(gate)),
        "gate_failure_mean": float(gate[y == 1].mean()) if (y == 1).any() else np.nan,
        "gate_normal_mean": float(gate[y == 0].mean()) if (y == 0).any() else np.nan,
        "history_mean": float(h.mean()), "gate_history_corr": corr,
    }


def print_table(title, df, cols=None, max_rows=None):
    print("\n" + title)
    print("-" * min(180, 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}"))
