
# -*- coding: utf-8 -*-
"""Suite18-only reporting helpers.

These helpers deliberately do not alter Suite17 metrics.  They only make the
inherited report labels truthful and summarize FMM-specific diagnostics so the
plain log is sufficient for scientific interpretation.
"""
from __future__ import annotations

import numpy as np
import pandas as pd


def suite18_title(title: str) -> str:
    return str(title).replace("SUITE17", "SUITE18").replace("Suite17", "Suite18")


def suite18_display_frame(df: pd.DataFrame) -> pd.DataFrame:
    """Rename inherited Suite17 display-only column labels to Suite18."""
    z = df.copy()
    ren = {}
    for c in z.columns:
        nc = c
        if c.startswith("suite17_"):
            nc = "suite18_" + c[len("suite17_"):]
        elif c.startswith("s17_"):
            nc = "s18_" + c[len("s17_"):]
        ren[c] = nc
    return z.rename(columns=ren)


def prequential_summary_rows(df: pd.DataFrame) -> list[dict]:
    if df is None or len(df) == 0:
        return []
    rows = []
    for view, g in df.groupby("view", sort=False):
        avail = g["available"].astype(bool) if "available" in g else pd.Series(False, index=g.index)
        ga = g[avail].copy()
        violations = 0
        max_gap = np.nan
        if len(ga) and {"max_train_block", "query_block"}.issubset(ga.columns):
            tr = pd.to_numeric(ga["max_train_block"], errors="coerce").to_numpy(float)
            qu = pd.to_numeric(ga["query_block"], errors="coerce").to_numpy(float)
            finite = np.isfinite(tr) & np.isfinite(qu)
            if np.any(finite):
                gap = tr[finite] - qu[finite]
                violations = int(np.sum(gap >= 0))
                max_gap = float(np.max(gap))
        rows.append({
            "view": view,
            "blocks": int(len(g)),
            "available_blocks": int(avail.sum()),
            "unavailable_blocks": int((~avail).sum()),
            "availability_rate": float(avail.mean()) if len(avail) else np.nan,
            "first_available_block": (
                float(pd.to_numeric(ga["query_block"], errors="coerce").min())
                if len(ga) and "query_block" in ga else np.nan
            ),
            "last_available_block": (
                float(pd.to_numeric(ga["query_block"], errors="coerce").max())
                if len(ga) and "query_block" in ga else np.nan
            ),
            "min_train_rows_when_available": (
                int(pd.to_numeric(ga["train_rows"], errors="coerce").min())
                if len(ga) and "train_rows" in ga else 0
            ),
            "max_train_rows_when_available": (
                int(pd.to_numeric(ga["train_rows"], errors="coerce").max())
                if len(ga) and "train_rows" in ga else 0
            ),
            "chronology_violations": violations,
            "max_train_minus_query": max_gap,
        })
    return rows


def feature_selection_preview_rows(df: pd.DataFrame, top_n: int = 10) -> pd.DataFrame:
    if df is None or len(df) == 0:
        return pd.DataFrame()
    z = df.copy()
    if "selected" in z:
        z = z[z["selected"].astype(bool)]
    if "rank" in z:
        z = z.sort_values(["view", "rank"])
    keep = [c for c in ["fold", "view", "rank", "feature", "f_score", "initialization_block"] if c in z]
    return z[keep].groupby("view", group_keys=False).head(int(top_n)).reset_index(drop=True)


def hyperbox_summary_for_log(df: pd.DataFrame) -> pd.DataFrame:
    if df is None or len(df) == 0:
        return pd.DataFrame()
    keep = [
        "fold", "view", "theta", "class", "boxes", "support", "support_median",
        "support_p95", "confidence_mean", "confidence_p95",
        "width_mean", "width_p95", "contraction_events",
    ]
    return df[[c for c in keep if c in df.columns]].copy()


def reference_head_to_head(meanf: pd.DataFrame, candidate: str) -> pd.DataFrame:
    """Pairwise faculty-level comparison of candidate vs every available model."""
    if meanf is None or len(meanf) == 0:
        return pd.DataFrame()
    cand = meanf[meanf["model"] == candidate].copy()
    if cand.empty:
        return pd.DataFrame()
    metrics = {
        "ap": "mean_fold_ap",
        "auc": "mean_fold_auc",
        "f2": "mean_fold_f2_at_20",
    }
    rows = []
    for ref in sorted(m for m in meanf["model"].dropna().unique() if m != candidate):
        other = meanf[meanf["model"] == ref].copy()
        cols = ["faculty"] + [c for c in metrics.values() if c in cand.columns and c in other.columns]
        if len(cols) <= 1:
            continue
        a = cand[cols].rename(columns={c:f"candidate_{c}" for c in cols if c!="faculty"})
        b = other[cols].rename(columns={c:f"reference_{c}" for c in cols if c!="faculty"})
        z = a.merge(b, on="faculty", how="inner")
        if z.empty:
            continue
        row = {"reference": ref, "faculties": int(len(z))}
        for short, col in metrics.items():
            ac, bc = f"candidate_{col}", f"reference_{col}"
            if ac not in z or bc not in z:
                continue
            delta = z[ac].to_numpy(float) - z[bc].to_numpy(float)
            row[f"candidate_macro_{short}"] = float(np.nanmean(z[ac]))
            row[f"reference_macro_{short}"] = float(np.nanmean(z[bc]))
            row[f"mean_delta_{short}"] = float(np.nanmean(delta))
            row[f"median_delta_{short}"] = float(np.nanmedian(delta))
            row[f"worst_delta_{short}"] = float(np.nanmin(delta))
            row[f"{short}_wins"] = int(np.nansum(delta > 0))
            row[f"{short}_win_rate"] = float(np.nanmean(delta > 0))
        rows.append(row)
    if not rows:
        return pd.DataFrame()
    return pd.DataFrame(rows).sort_values(
        ["mean_delta_ap", "mean_delta_f2"],
        ascending=False,
        na_position="last",
    ).reset_index(drop=True)
