"""Demographic confound & shortcut-baseline analysis (P10, Table 5 part 1).

Purpose: show how much of the 3-class signal is recoverable from demographics /
morphometry ALONE (no MRI). If an age-only model is already strong, the dataset
has confounding that must be discussed honestly rather than hidden.

Shortcut baselines:
  - age-only logistic regression
  - demographic XGBoost (age, sex, education, ses)
  - full-structured XGBoost (demographic + eTIV, nWBV, ASF)

All evaluated on the SAME subject-level folds/seeds as the main experiments,
using out-of-fold predictions so numbers are directly comparable to Table 3.
Never uses CDR or MMSE (label leakage).
"""
from __future__ import annotations

from pathlib import Path

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

from trifuse.data.splits import make_folds, split_for, SEEDS, N_FOLDS
from trifuse.eval.metrics import compute_metrics
from trifuse.models.baselines_tab import make_xgb

DEMO_COLS = ["age", "sex", "education", "ses"]
FULL_COLS = ["age", "sex", "education", "ses", "etiv", "nwbv", "asf"]


def _oof_predict(df: pd.DataFrame, feature_cols: list[str], model_kind: str) -> pd.DataFrame:
    """Run repeated CV, return per-subject OOF predictions (one row per subject per seed)."""
    folds = make_folds(df)
    records = []
    for seed in SEEDS:
        for fold in range(N_FOLDS):
            tr_ids, va_ids, te_ids = split_for(folds, df, seed, fold)
            tr = df[df["subject_id"].isin(set(tr_ids) | set(va_ids))]
            te = df[df["subject_id"].isin(te_ids)]

            Xtr = tr[feature_cols].to_numpy(dtype=float)
            ytr = tr["class_id"].to_numpy(dtype=int)
            Xte = te[feature_cols].to_numpy(dtype=float)
            yte = te["class_id"].to_numpy(dtype=int)

            # impute (train medians) + standardize
            med = np.nanmedian(Xtr, axis=0)
            Xtr = np.where(np.isnan(Xtr), med, Xtr)
            Xte = np.where(np.isnan(Xte), med, Xte)
            sc = StandardScaler().fit(Xtr)
            Xtr, Xte = sc.transform(Xtr), sc.transform(Xte)

            if model_kind == "logreg":
                clf = LogisticRegression(max_iter=1000, class_weight="balanced")
                clf.fit(Xtr, ytr)
                prob = clf.predict_proba(Xte)
            else:  # xgboost
                clf = make_xgb(n_classes=3, seed=seed)
                clf.fit(Xtr, ytr)
                prob = clf.predict_proba(Xte)

            pred = prob.argmax(1)
            for sid, yt, yp, pr in zip(te_ids, yte, pred, prob):
                records.append({"subject_id": sid, "seed": seed, "fold": fold,
                                "y_true": int(yt), "y_pred": int(yp),
                                "p0": pr[0], "p1": pr[1], "p2": pr[2]})
    return pd.DataFrame(records)


def run_confound(subjects_csv: str | Path, out_dir: str | Path) -> pd.DataFrame:
    df = pd.read_csv(subjects_csv)
    df = df[df["class_id"].notna()].reset_index(drop=True)
    df["class_id"] = df["class_id"].astype(int)
    out_dir = Path(out_dir); out_dir.mkdir(parents=True, exist_ok=True)

    configs = [
        ("age_only_logreg", ["age"], "logreg"),
        ("demographic_xgb", DEMO_COLS, "xgboost"),
        ("full_structured_xgb", FULL_COLS, "xgboost"),
    ]
    summary = []
    for name, cols, kind in configs:
        oof = _oof_predict(df, cols, kind)
        oof.to_csv(out_dir / f"oof_{name}.csv", index=False)
        # aggregate metric per seed then mean+/-std
        per_seed = []
        for seed in SEEDS:
            s = oof[oof["seed"] == seed]
            m = compute_metrics(s["y_true"].to_numpy(), s["y_pred"].to_numpy(),
                                s[["p0", "p1", "p2"]].to_numpy())
            per_seed.append(m)
        macro_f1 = np.array([m["macro_f1"] for m in per_seed])
        bal_acc = np.array([m["balanced_accuracy"] for m in per_seed])
        ad_recall = np.array([m["recall_AD"] for m in per_seed])
        summary.append({
            "model": name,
            "macro_f1_mean": macro_f1.mean(), "macro_f1_std": macro_f1.std(),
            "bal_acc_mean": bal_acc.mean(), "bal_acc_std": bal_acc.std(),
            "ad_recall_mean": ad_recall.mean(), "ad_recall_std": ad_recall.std(),
        })
    res = pd.DataFrame(summary)
    res.to_csv(out_dir / "confound_summary.csv", index=False)
    return res


if __name__ == "__main__":
    import sys
    csv = sys.argv[1] if len(sys.argv) > 1 else "data/metadata/subjects_clean.csv"
    out = sys.argv[2] if len(sys.argv) > 2 else "results/tables/confound"
    print(run_confound(csv, out).to_string(index=False))