"""Phase C report: accuracy vs window, SNR law (H4), cross-half (H6), stream order (H9), pipelines (H5).

Per subject: accuracy(w) = correct windows / windows over all the subject's trials (non-overlapping windows);
1-s evidence d = r_att - r_ign (non-overlapping), SNR_1 = mean(d) / SD(d) pooled over the subject's windows.
SNR law: accuracy(w) ~ Phi(k * SNR_1 * sqrt(w)); k fitted per dataset x scheme by least squares over subjects
and w (only (subject, w) cells with >= 5 windows). k = 1 means independent 1-s windows.
Writes tables/decoder_*.csv, tables/per_subject_metrics_decoders.csv, tables/stream_order_audit*.csv,
tables/crosshalf_h6*.csv, figures/c4_*.png
"""
import glob
import os
import sys

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt  # noqa: E402
import numpy as np  # noqa: E402
import pandas as pd  # noqa: E402
from scipy import optimize, stats  # noqa: E402

sys.path.insert(0, os.path.dirname(__file__))
from common import CACHE, COLORS, DS_KEYS, LABELS, TAB, boot_ci, fdr_bh, get_logger, savefig  # noqa: E402

log = get_logger("c4_decoder_report")
MAIN = "c19-common57-car"


def subject_table(cfg, scheme):
    p = os.path.join(CACHE, "eval", cfg, f"{scheme}.parquet")
    if not os.path.exists(p):
        return None
    w = pd.read_parquet(p)
    t = pd.read_parquet(os.path.join(CACHE, "eval", cfg, f"{scheme}_trial.parquet"))
    acc = (w.groupby(["ds", "subj_uid", "lag", "w"], observed=True)
           .agg(n_win=("n_win", "sum"), n_correct=("n_correct", "sum")).reset_index())
    acc["acc"] = acc.n_correct / acc.n_win.replace(0, np.nan)
    ev = (t.groupby(["ds", "subj_uid", "lag"], observed=True)
          .agg(n1=("n1", "sum"), sd=("sum_d", "sum"), sd2=("sum_d2", "sum")).reset_index())
    ev["mean_d"] = ev.sd / ev.n1
    ev["sd_d"] = np.sqrt(np.maximum(ev.sd2 / ev.n1 - ev.mean_d ** 2, 1e-12))
    ev["snr1"] = ev.mean_d / ev.sd_d
    acc = acc.merge(ev[["ds", "subj_uid", "lag", "snr1", "mean_d", "sd_d", "n1"]], on=["ds", "subj_uid", "lag"])
    acc["cfg"], acc["scheme"] = cfg, scheme
    return acc


def fit_k(g):
    g = g[(g.n_win >= 5) & g.acc.notna()]
    if len(g) < 3:
        return np.nan

    def loss(k):
        return np.sum((g.acc - stats.norm.cdf(k * g.snr1 * np.sqrt(g.w))) ** 2)

    return float(optimize.minimize_scalar(loss, bounds=(0.05, 5), method="bounded").x)


if __name__ == "__main__":
    tabs = []
    for cfg in sorted(os.listdir(os.path.join(CACHE, "eval"))):
        for p in sorted(glob.glob(os.path.join(CACHE, "eval", cfg, "*.parquet"))):
            sc = os.path.basename(p)[:-8]
            if sc.endswith("_trial") or sc.startswith("xh_"):
                continue
            t = subject_table(cfg, sc)
            if t is not None:
                tabs.append(t)
    A = pd.concat(tabs, ignore_index=True)
    A.to_csv(os.path.join(TAB, "per_subject_metrics_decoders.csv"), index=False)

    # ---------------- accuracy vs window (main cfg)
    main = A[A.cfg == MAIN]
    rows = []
    for (sc, lag, ds, w), g in main.groupby(["scheme", "lag", "ds", "w"], observed=True):
        v = g.acc.dropna()
        if len(v) == 0:
            continue
        m, lo, hi = boot_ci(v.values)
        rows.append(dict(scheme=sc, lag=lag, ds=ds, w=w, n_subjects=len(v), n_windows=int(g.n_win.sum()),
                         median_acc=m, ci_lo=lo, ci_hi=hi))
    acc_w = pd.DataFrame(rows)
    acc_w.to_csv(os.path.join(TAB, "decoder_accuracy_vs_window.csv"), index=False)
    log.info("\n" + acc_w[acc_w.lag == "0-500ms"].pivot_table(index=["scheme", "w"], columns="ds",
                                                              values="median_acc").round(3).to_string())

    # ---------------- SNR law
    rows, pts = [], []
    for (sc, lag, ds), g in main.groupby(["scheme", "lag", "ds"], observed=True):
        s = g.drop_duplicates("subj_uid")
        k = fit_k(g)
        m, lo, hi = boot_ci(s.snr1.values)
        rows.append(dict(scheme=sc, lag=lag, ds=ds, n_subjects=len(s), snr1_median=m, snr1_ci_lo=lo, snr1_ci_hi=hi,
                         k=k, acc1_median=float(g[g.w == 1].acc.median())))
        gg = g[g.n_win >= 5].copy()
        gg["pred"] = stats.norm.cdf(k * gg.snr1 * np.sqrt(gg.w))
        pts.append(gg)
    snr = pd.DataFrame(rows)
    snr.to_csv(os.path.join(TAB, "decoder_snr_law.csv"), index=False)
    base_snr = stats.norm.ppf(0.5394)
    log.info(f"official baseline 53.94% at 1 s implies SNR_1 = {base_snr:.4f} (k = 1)\n" + snr.round(4).to_string())
    pts = pd.concat(pts)
    fig, axs = plt.subplots(1, 3, figsize=(16, 4.8))
    for ax, sc in zip(axs, ["loto", "loso", "lodo_pool"]):
        g = pts[(pts.scheme == sc) & (pts.lag == "0-500ms")]
        for ds in DS_KEYS:
            gd = g[g.ds == ds]
            kk = snr[(snr.scheme == sc) & (snr.ds == ds) & (snr.lag == "0-500ms")].k
            ax.scatter(gd.pred, gd.acc, s=6, color=COLORS[ds], alpha=0.6,
                       label=f"{LABELS[ds]} k={kk.iloc[0]:.2f}" if len(kk) else LABELS[ds])
        ax.plot([0.4, 1], [0.4, 1], "k--", lw=0.8)
        ax.set_xlabel("predicted Phi(k SNR1 sqrt(w))")
        ax.set_ylabel("measured accuracy")
        ax.set_title(f"{sc}, lags 0-500 ms (dot = subject x window length)", fontsize=9)
        ax.legend(fontsize=7)
    savefig(fig, "c4_snr_law", pts[["scheme", "lag", "ds", "subj_uid", "w", "acc", "pred", "snr1"]])

    fig, axs = plt.subplots(1, 3, figsize=(16, 4.5), sharey=True)
    for ax, sc in zip(axs, ["loto", "loso", "lodo_pool"]):
        g = acc_w[(acc_w.scheme == sc) & (acc_w.lag == "0-500ms")]
        for ds in DS_KEYS:
            gd = g[g.ds == ds]
            if not len(gd):
                continue
            ax.errorbar(gd.w, gd.median_acc, yerr=[gd.median_acc - gd.ci_lo, gd.ci_hi - gd.median_acc],
                        color=COLORS[ds], marker="o", ms=3, capsize=2,
                        label=f"{LABELS[ds]} (n={int(gd.n_subjects.max())} subjects)")
        ax.set_xscale("log")
        ax.axhline(0.5, color="gray", lw=0.8)
        ax.set_xlabel("window length (s)")
        ax.set_title(f"{sc}: median subject accuracy, 95% bootstrap CI", fontsize=9)
        ax.legend(fontsize=7)
    axs[0].set_ylabel("accuracy")
    savefig(fig, "c4_accuracy_vs_window", acc_w)

    # ---------------- H9 stream-order audit (whole-trial correlations)
    rows, flag = [], []
    for sc in ("loso", "lodo_pool"):
        p = os.path.join(CACHE, "eval", MAIN, f"{sc}_trial.parquet")
        if not os.path.exists(p):
            continue
        t = pd.read_parquet(p)
        t = t[t.lag == "0-500ms"].copy()
        t["col1_wins"] = t.r_col1 > t.r_col0
        for ds in DS_KEYS:
            g = t[t.ds == ds]
            k, n = int(g.col1_wins.sum()), len(g)
            rows.append(dict(scheme=sc, ds=ds, n_trials=n, share_col1_wins=k / n,
                             binom_p_vs_half=stats.binomtest(k, n, 0.5).pvalue,
                             median_r_col0=float(g.r_col0.median()), median_r_col1=float(g.r_col1.median()),
                             wilcoxon_r0_vs_r1_p=stats.wilcoxon(g.r_col0, g.r_col1).pvalue))
            for s, gs in g.groupby("subj_uid"):
                ks, ns = int(gs.col1_wins.sum()), len(gs)
                flag.append(dict(scheme=sc, ds=ds, subj=s, n_trials=ns, col1_wins=ks,
                                 p_col1_majority=stats.binomtest(ks, ns, 0.5, alternative="greater").pvalue))
    h9 = pd.DataFrame(rows)
    fl = pd.DataFrame(flag)
    if len(fl):
        fl["q"] = np.nan
        for sc in fl.scheme.unique():
            m = fl.scheme == sc
            fl.loc[m, "q"] = fdr_bh(fl.loc[m, "p_col1_majority"].values)
        h9.to_csv(os.path.join(TAB, "stream_order_audit.csv"), index=False)
        fl.to_csv(os.path.join(TAB, "stream_order_audit_subjects.csv"), index=False)
        log.info("\n" + h9.round(4).to_string() + "\nsubjects with col1 majority at FDR q<0.05:\n"
                 + fl[fl.q < 0.05].to_string())

    # ---------------- H6 cross-half (KUL-AV-GC)
    xs = []
    for dec in ("xh_h1", "xh_h2B", "xh_h2A"):
        p = os.path.join(CACHE, "eval", MAIN, f"{dec}.parquet")
        if not os.path.exists(p):
            continue
        w = pd.read_parquet(p)
        w = w[w.lag == "0-500ms"]
        g = w.groupby(["subj_uid", "w"]).agg(n=("n_win", "sum"), c0=("n_col0", "sum")).reset_index()
        g["frac_col0"] = g.c0 / g.n
        g["dec"] = dec
        xs.append(g)
    if xs:
        X = pd.concat(xs)
        out = []
        for w_, g in X.groupby("w"):
            h1 = g[g.dec == "xh_h1"].set_index("subj_uid").frac_col0       # tested on half 2
            h2B = g[g.dec == "xh_h2B"].set_index("subj_uid").frac_col0     # tested on half 1 (trained col0 on half 2)
            h2A = g[g.dec == "xh_h2A"].set_index("subj_uid").frac_col0     # tested on half 1 (trained col1 on half 2)
            accB = (h1 + h2B) / 2                                          # B: same speaker attended all trial
            accA = ((1 - h1) + h2A) / 2                                    # A: attended speaker changes at 5 min
            for name, v in (("hypB_no_speaker_switch", accB), ("hypA_speaker_switch_at_5min", accA)):
                v = v.dropna()
                m, lo, hi = boot_ci(v.values)
                out.append(dict(w=w_, hypothesis=name, n_subjects=len(v), n_windows=int(g.n.sum()), median_acc=m,
                                ci_lo=lo, ci_hi=hi,
                                wilcoxon_vs_0p5=stats.wilcoxon(v.values - 0.5).pvalue if (v != 0.5).sum() > 5 else np.nan))
        xh = pd.DataFrame(out)
        xh.to_csv(os.path.join(TAB, "crosshalf_h6.csv"), index=False)
        X.to_csv(os.path.join(TAB, "crosshalf_h6_per_subject.csv"), index=False)
        log.info("\n" + xh.round(4).to_string())

    # ---------------- LODO aggregation + pipeline comparison (paired per subject vs MAIN lodo_pool)
    lod = A[A.scheme.str.startswith("lodo") & A.w.isin([1, 10])]
    ref = lod[(lod.cfg == MAIN) & (lod.scheme == "lodo_pool")][["subj_uid", "lag", "w", "acc", "snr1"]]
    rows = []
    for (cfg, sc, lag, w), g in lod.groupby(["cfg", "scheme", "lag", "w"]):
        mm = g.merge(ref, on=["subj_uid", "lag", "w"], suffixes=("", "_ref"))
        for ds in DS_KEYS + ["ALL"]:
            gd = mm if ds == "ALL" else mm[mm.ds == ds]
            if len(gd) == 0:
                continue
            dacc = (gd.acc - gd.acc_ref).values
            b = boot_ci(dacc)
            rows.append(dict(cfg=cfg, scheme=sc, lag=lag, w=w, ds=ds, n_subjects=len(gd),
                             median_acc=float(gd.acc.median()), median_snr1=float(gd.snr1.median()),
                             median_delta_acc_vs_main=b[0], delta_ci_lo=b[1], delta_ci_hi=b[2],
                             wilcoxon_p=stats.wilcoxon(dacc).pvalue if (dacc != 0).sum() > 5 else np.nan))
    pc = pd.DataFrame(rows)
    pc.to_csv(os.path.join(TAB, "decoder_pipeline_comparison.csv"), index=False)
    log.info("\n" + pc[pc.ds == "ALL"].round(4).to_string())
