from __future__ import annotations

import numpy as np
import torch


def dice_score(logits: torch.Tensor, target: torch.Tensor, threshold: float = 0.5, eps: float = 1e-6) -> float:
    pred = (torch.sigmoid(logits) >= threshold).float()
    target = target.float()
    dims = tuple(range(1, pred.ndim))
    score = (2.0 * (pred * target).sum(dim=dims) + eps) / ((pred + target).sum(dim=dims) + eps)
    return float(score.mean().detach().cpu())


def iou_score(logits: torch.Tensor, target: torch.Tensor, threshold: float = 0.5, eps: float = 1e-6) -> float:
    pred = (torch.sigmoid(logits) >= threshold).float()
    target = target.float()
    dims = tuple(range(1, pred.ndim))
    score = ((pred * target).sum(dim=dims) + eps) / (((pred + target) > 0).float().sum(dim=dims) + eps)
    return float(score.mean().detach().cpu())


def assd_voxels(logits: torch.Tensor, target: torch.Tensor, threshold: float = 0.5) -> float:
    pred = (torch.sigmoid(logits) >= threshold).detach().cpu().numpy().astype(bool)
    true = target.detach().cpu().numpy().astype(bool)
    try:
        from scipy import ndimage
    except Exception:
        return float("nan")

    values = []
    for p, t in zip(pred, true):
        p = np.squeeze(p)
        t = np.squeeze(t)
        if not p.any() and not t.any():
            values.append(0.0)
            continue
        if not p.any() or not t.any():
            values.append(float("nan"))
            continue
        p_surface = p ^ ndimage.binary_erosion(p)
        t_surface = t ^ ndimage.binary_erosion(t)
        p_to_t = ndimage.distance_transform_edt(~t_surface)[p_surface]
        t_to_p = ndimage.distance_transform_edt(~p_surface)[t_surface]
        values.append(float((p_to_t.mean() + t_to_p.mean()) / 2.0))
    return float(np.nanmean(values)) if values else float("nan")


def binary_classification_metrics(logits: torch.Tensor, target: torch.Tensor) -> dict[str, float]:
    y_true = target.detach().cpu().numpy().astype(float)
    y_prob = torch.sigmoid(logits).detach().cpu().numpy().astype(float)
    valid = np.isfinite(y_true)
    y_true = y_true[valid]
    y_prob = y_prob[valid]
    if y_true.size == 0:
        return {
            "brier": float("nan"),
            "accuracy": float("nan"),
            "auc": float("nan"),
            "ap": float("nan"),
            "balanced_accuracy": float("nan"),
            "sensitivity": float("nan"),
            "specificity": float("nan"),
        }
    out = {"brier": float(np.mean((y_prob - y_true) ** 2))}
    y_pred = (y_prob >= 0.5).astype(float)
    out["accuracy"] = float(np.mean(y_pred == y_true))
    pos = y_true == 1.0
    neg = y_true == 0.0
    out["sensitivity"] = float(np.mean(y_pred[pos] == 1.0)) if pos.any() else float("nan")
    out["specificity"] = float(np.mean(y_pred[neg] == 0.0)) if neg.any() else float("nan")
    try:
        from sklearn.metrics import average_precision_score, balanced_accuracy_score, roc_auc_score

        out["auc"] = float(roc_auc_score(y_true, y_prob))
        out["ap"] = float(average_precision_score(y_true, y_prob))
        out["balanced_accuracy"] = float(balanced_accuracy_score(y_true, y_pred))
    except Exception:
        out["auc"] = float("nan")
        out["ap"] = float("nan")
        out["balanced_accuracy"] = float("nan")
    return out


def expected_calibration_error(logits: torch.Tensor, target: torch.Tensor, bins: int = 10) -> float:
    prob = torch.sigmoid(logits).detach().cpu().numpy()
    y = target.detach().cpu().numpy()
    valid = np.isfinite(y)
    prob = prob[valid]
    y = y[valid]
    if y.size == 0:
        return float("nan")
    edges = np.linspace(0.0, 1.0, bins + 1)
    ece = 0.0
    for lo, hi in zip(edges[:-1], edges[1:]):
        mask = (prob >= lo) & (prob < hi)
        if mask.any():
            ece += mask.mean() * abs(prob[mask].mean() - y[mask].mean())
    return float(ece)


def concordance_index(risk: torch.Tensor, time: torch.Tensor, event: torch.Tensor) -> float:
    risk_np = risk.detach().cpu().numpy().astype(float)
    time_np = time.detach().cpu().numpy().astype(float)
    event_np = event.detach().cpu().numpy().astype(float)
    valid = np.isfinite(risk_np) & np.isfinite(time_np) & np.isfinite(event_np)
    risk_np = risk_np[valid]
    time_np = time_np[valid]
    event_np = event_np[valid]
    comparable = 0.0
    concordant = 0.0
    for i in range(len(risk_np)):
        for j in range(len(risk_np)):
            if time_np[i] < time_np[j] and event_np[i] > 0.5:
                comparable += 1.0
                if risk_np[i] > risk_np[j]:
                    concordant += 1.0
                elif risk_np[i] == risk_np[j]:
                    concordant += 0.5
    return float(concordant / comparable) if comparable > 0 else float("nan")