"""Evaluation metrics in physical units."""
from __future__ import annotations

from typing import Dict, List

import numpy as np

from .data import TARGETS, TARGET_KEYS

# Targets used for the headline macro average (see docs/data_card.md).
# The 6 dislocation-type breakdown targets are reported separately: several are
# annotated in only 3-6 of the 33 samples and have near-zero variance, which
# makes R2 numerically meaningless as a macro-average component.
PRIMARY = ("sigma", "xi_BCC", "xi_FCC", "xi_HCP", "xi_other", "rho_total", "twin")


def _r2(y, p):
    if len(y) < 2:
        return float("nan")
    ss_res = float(np.sum((y - p) ** 2))
    ss_tot = float(np.sum((y - y.mean()) ** 2))
    if ss_tot < 1e-12:
        return float("nan")
    return 1.0 - ss_res / ss_tot


def regression_metrics(raw_true: np.ndarray, raw_pred: np.ndarray,
                       mask: np.ndarray) -> Dict[str, Dict[str, float]]:
    """raw_*: (N, Ft) physical units; mask: (N, Ft) 0/1."""
    out = {}
    for j, t in enumerate(TARGETS):
        m = mask[:, j] > 0
        n = int(m.sum())
        if n == 0:
            out[t.key] = {"n": 0, "r2": float("nan"), "mae": float("nan"),
                          "rmse": float("nan"), "unit": t.unit, "group": t.group}
            continue
        y, p = raw_true[m, j], raw_pred[m, j]
        sd = float(np.std(y))
        mae = float(np.mean(np.abs(y - p)))
        r2_log = float("nan")
        if t.group in ("dislocation", "twin") or t.transform == "asinh":
            ly, lp = np.log1p(np.maximum(y, 0)), np.log1p(np.maximum(p, 0))
            r2_log = _r2(ly, lp)
        out[t.key] = {
            "n": n,
            "r2": _r2(y, p),
            "r2_log": r2_log,
            "mae": mae,
            "nmae": mae / sd if sd > 1e-12 else float("nan"),
            "rmse": float(np.sqrt(np.mean((y - p) ** 2))),
            "bias": float(np.mean(p - y)),
            "y_std": sd,
            "unit": t.unit,
            "group": t.group,
        }
    return out


def curve_metrics(strain: np.ndarray, sig_true: np.ndarray, sig_pred: np.ndarray,
                  eps_list=(0.02, 0.05, 0.10)) -> Dict[str, float]:
    """Per-sample macroscopic curve descriptors."""
    out = {}
    pk_t = float(np.max(sig_true))
    pk_p = float(np.max(sig_pred))
    out["peak_true"] = pk_t
    out["peak_pred"] = pk_p
    out["peak_rel_err"] = abs(pk_p - pk_t) / max(abs(pk_t), 1e-6)
    for e in eps_list:
        i = int(np.argmin(np.abs(strain - e)))
        out[f"sig@{e:g}_true"] = float(sig_true[i])
        out[f"sig@{e:g}_pred"] = float(sig_pred[i])
        out[f"sig@{e:g}_rel_err"] = abs(sig_pred[i] - sig_true[i]) / max(abs(sig_true[i]), 1e-6)
    out["curve_rmse"] = float(np.sqrt(np.mean((sig_pred - sig_true) ** 2)))
    return out


def summarise(per_target: Dict[str, Dict[str, float]]) -> Dict[str, float]:
    """Macro-average R2 / MAE over the targets that actually have labels."""
    r2s = [v["r2"] for v in per_target.values() if v["n"] > 0 and np.isfinite(v["r2"])]
    r2l = [v["r2_log"] for v in per_target.values()
           if v["n"] > 0 and np.isfinite(v.get("r2_log", float("nan")))]
    nm = [v["nmae"] for v in per_target.values()
          if v["n"] > 0 and np.isfinite(v.get("nmae", float("nan")))]
    core = [v["r2"] for v in per_target.values()
            if v["n"] >= 1500 and np.isfinite(v["r2"])]
    prim = [per_target[k]["r2"] for k in PRIMARY
            if k in per_target and per_target[k]["n"] > 0
            and np.isfinite(per_target[k]["r2"])]
    return {
        "macro_r2": float(np.mean(r2s)) if r2s else float("nan"),
        "macro_r2_primary": float(np.mean(prim)) if prim else float("nan"),
        "n_primary": len(prim),
        "core_r2": float(np.mean(core)) if core else float("nan"),
        "median_r2": float(np.median(r2s)) if r2s else float("nan"),
        "macro_r2_log": float(np.mean(r2l)) if r2l else float("nan"),
        "macro_nmae": float(np.mean(nm)) if nm else float("nan"),
        "n_targets_scored": len(r2s),
    }

def sigma_decomposition(raw_true, raw_pred, mask, sid, j=0):
    """Split stress accuracy into an alloy-level term and a curve-shape term.

    level_oracle_r2 : R2 of a predictor that knows each sample's *mean* stress
                      exactly but has no shape  -> upper bound of a level-only model.
    shape_r2        : R2 after removing each sample's own mean from both curves
                      -> how well the *shape* (hardening/softening) is captured.
    """
    m = mask[:, :, j] > 0
    y, p = raw_true[:, :, j], raw_pred[:, :, j]
    yv, pv = y[m], p[m]
    if len(yv) < 4:
        return {}
    r2 = _r2(yv, pv)
    lv_t, lv_p = [], []
    ys, ps = [], []
    for i in range(y.shape[0]):
        s = m[i]
        if s.sum() < 4:
            continue
        lv_t.append(y[i, s].mean()); lv_p.append(p[i, s].mean())
        ys.append(y[i, s] - y[i, s].mean()); ps.append(p[i, s] - p[i, s].mean())
    lv_t, lv_p = np.array(lv_t), np.array(lv_p)
    ys, ps = np.concatenate(ys), np.concatenate(ps)
    return {
        "r2": r2,
        "level_oracle_r2": _r2(yv, np.concatenate([np.full(int(m[i].sum()), y[i, m[i]].mean())
                                                  for i in range(y.shape[0]) if m[i].sum() >= 4])),
        "shape_r2": _r2(ys, ps),
        "level_corr": float(np.corrcoef(lv_t, lv_p)[0, 1]) if len(lv_t) > 2 else float("nan"),
        "level_mae_GPa": float(np.mean(np.abs(lv_t - lv_p))),
        "level_bias_GPa": float(np.mean(lv_p - lv_t)),
        "n_samples": len(lv_t),
    }