"""Evaluation metrics for 3-class Alzheimer staging.

Primary metric is Macro-F1 (class imbalance: AD is the minority). All metrics
computed from (y_true, y_pred) label arrays plus optional probabilities for AUC.
"""
from __future__ import annotations

import numpy as np
from sklearn.metrics import (
    accuracy_score,
    balanced_accuracy_score,
    confusion_matrix,
    f1_score,
    precision_score,
    recall_score,
    roc_auc_score,
)

CLASS_NAMES = ["CN", "VMD", "AD"]  # 0, 1, 2
N_CLASSES = 3


def compute_metrics(
    y_true: np.ndarray,
    y_pred: np.ndarray,
    y_prob: np.ndarray | None = None,
) -> dict[str, float]:
    """Return the full metric dict for one set of predictions.

    y_prob: (N, 3) class probabilities; if given, OvR macro-AUC is added.
    """
    y_true = np.asarray(y_true).astype(int)
    y_pred = np.asarray(y_pred).astype(int)
    labels = list(range(N_CLASSES))

    out: dict[str, float] = {
        "accuracy": float(accuracy_score(y_true, y_pred)),
        "balanced_accuracy": float(balanced_accuracy_score(y_true, y_pred)),
        "macro_f1": float(f1_score(y_true, y_pred, labels=labels, average="macro", zero_division=0)),
        "macro_precision": float(precision_score(y_true, y_pred, labels=labels, average="macro", zero_division=0)),
        "macro_recall": float(recall_score(y_true, y_pred, labels=labels, average="macro", zero_division=0)),
    }

    per_f1 = f1_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
    per_recall = recall_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
    per_prec = precision_score(y_true, y_pred, labels=labels, average=None, zero_division=0)
    for i, name in enumerate(CLASS_NAMES):
        out[f"f1_{name}"] = float(per_f1[i])
        out[f"recall_{name}"] = float(per_recall[i])
        out[f"precision_{name}"] = float(per_prec[i])

    if y_prob is not None:
        y_prob = np.asarray(y_prob, dtype=float)
        # OvR macro-AUC; guard against a class absent from y_true in this split.
        present = np.unique(y_true)
        if len(present) == N_CLASSES:
            try:
                out["macro_auc"] = float(
                    roc_auc_score(y_true, y_prob, multi_class="ovr", average="macro", labels=labels)
                )
            except ValueError:
                out["macro_auc"] = float("nan")
        else:
            out["macro_auc"] = float("nan")
    return out


def confusion(y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:
    return confusion_matrix(np.asarray(y_true).astype(int),
                            np.asarray(y_pred).astype(int),
                            labels=list(range(N_CLASSES)))