"""Phase B audits that need only labels and envelopes.

  B1  label audit           -> tables/label_audit.csv (per trial), tables/label_audit_summary.csv
  B4  envelope asymmetry    -> tables/env_asymmetry_*.csv, figures/b4_env_sd_ratio.png
      + "loud column" classifier (envelope statistics only, LOSO within dataset and LODO)
  B5  design confounds      -> tables/design_parity.csv, tables/design_order.csv (drift-only classifier is b3)
  B6  stimulus reuse        -> tables/stim_reuse_*.csv (name-based + envelope fingerprint)
  B7  envelope character    -> tables/env_character.csv, figures/b7_env_modspec.png
"""
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 joblib import Parallel, delayed  # noqa: E402
from scipy import signal, stats  # noqa: E402
from sklearn.linear_model import LogisticRegression  # noqa: E402
from sklearn.pipeline import make_pipeline  # noqa: E402
from sklearn.preprocessing import StandardScaler  # noqa: E402

sys.path.insert(0, os.path.dirname(__file__))
from common import (COLORS, DS_KEYS, FS, LABELS, SEED, TAB, boot_ci, get_logger, load_env,  # noqa: E402
                    load_labels, savefig, sos_bp, trial_index)

log = get_logger("b2_envelope_audit")


# ---------------------------------------------------------------------------
def per_trial(row):
    key = row["key"]
    e = load_env(key).astype(float)
    lab = load_labels(key)
    az = lab["att_az"].astype(float)
    att = lab["att_stream"].astype(int)
    T = len(e)
    r = dict(key=key, ds=row["ds"], subject=row["subject"], trial=row["trial"], sh_label=row["label"],
             dur_s=T / FS)
    # labels
    side0 = np.sign(az[0])
    lab_side = {"left": -1, "l": -1, "right": 1, "r": 1}.get(str(row["label"]).lower(), 0)
    r.update(az_onset=az[0], az_values=";".join(str(int(v)) for v in np.unique(az)),
             label_matches_onset=bool(lab_side == side0),
             frac_samples_label_wrong_direction=float(np.mean(np.sign(az) != lab_side)),
             col0_stream=int(lab["col0_stream"]), n_speaker_switches=int(np.sum(np.diff(att) != 0)),
             n_direction_switches=int(np.sum(np.diff(np.sign(az)) != 0)),
             frac_col0_attended=float(np.mean(lab["att_col"] == 0)),
             wav_col0=str(lab["wav"][int(lab["col0_stream"]) - 1]),
             wav_col1=str(lab["wav"][2 - int(lab["col0_stream"])]), cond=str(lab["cond"]),
             orig_pos=int(lab["orig_pos"]))
    sw = np.flatnonzero(np.diff(np.sign(az)) != 0)
    r["direction_switch_s"] = float((sw[0] + 1) / FS) if len(sw) else np.nan
    # envelope statistics (column 0 = majority-attended)
    bp = signal.sosfiltfilt(sos_bp(1.0, 9.0, 4, FS), e - e.mean(0), axis=0)
    for c in (0, 1):
        x = e[:, c]
        r[f"mean{c}"], r[f"sd{c}"], r[f"min{c}"], r[f"max{c}"] = x.mean(), x.std(), x.min(), x.max()
        r[f"frac_neg{c}"] = float(np.mean(x < 0))
        r[f"kurt{c}"] = float(stats.kurtosis(x))
        r[f"skew{c}"] = float(stats.skew(x))
        r[f"p19_{c}"] = float(bp[:, c].var())
        r[f"frac_zero{c}"] = float(np.mean(np.abs(x) < 1e-9))
    r["sd_ratio"] = r["sd0"] / max(r["sd1"], 1e-12)
    r["col0_more_1_9"] = bool(r["p19_0"] > r["p19_1"])
    r["r_streams"] = float(np.corrcoef(e[:, 0], e[:, 1])[0, 1])
    f, P = signal.welch(e - e.mean(0), fs=FS, nperseg=min(8 * FS, T), axis=0)
    m = f <= 20
    return r, f[m], P[m].mean(1)


def loud_column_classifier(df):
    """Can envelope statistics alone pick the attended column? Pairs presented in random order."""
    rng = np.random.default_rng(SEED)
    feats = ["mean", "sd", "p19_", "kurt", "skew", "max", "frac_neg"]
    X0 = np.column_stack([df[f"{f}0"] for f in feats])
    X1 = np.column_stack([df[f"{f}1"] for f in feats])
    flip = rng.random(len(df)) < 0.5
    A = np.where(flip[:, None], X1, X0)
    B = np.where(flip[:, None], X0, X1)
    # symmetric features: log-ratios / differences of the two columns
    X = np.column_stack([np.log(np.abs(A[:, 1]) / np.abs(B[:, 1])), np.log(A[:, 2] / B[:, 2]),
                         A[:, 0] - B[:, 0], A[:, 3] - B[:, 3], A[:, 4] - B[:, 4], A[:, 5] - B[:, 5],
                         A[:, 6] - B[:, 6]])
    y = (~flip).astype(int)                      # 1 = first presented column is the attended one
    X = np.nan_to_num(X)
    rows = []
    for scheme in ("LOSO", "LODO"):
        for ds in DS_KEYS:
            if scheme == "LOSO":
                dmask = (df.ds == ds).values
                groups = df.subject.values
                for s in np.unique(groups[dmask]):
                    te = dmask & (groups == s)
                    tr = dmask & (groups != s)
                    clf = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)).fit(X[tr], y[tr])
                    rows.append(dict(scheme=scheme, ds=ds, subject=s, acc=float((clf.predict(X[te]) == y[te]).mean()),
                                     n=int(te.sum())))
            else:
                te = (df.ds == ds).values
                clf = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)).fit(X[~te], y[~te])
                pr = clf.predict(X[te]) == y[te]
                for s in np.unique(df.subject.values[te]):
                    m = df.subject.values[te] == s
                    rows.append(dict(scheme=scheme, ds=ds, subject=s, acc=float(pr[m].mean()), n=int(m.sum())))
    return pd.DataFrame(rows)


if __name__ == "__main__":
    ti = trial_index()
    res = Parallel(n_jobs=4)(delayed(per_trial)(r) for _, r in ti.iterrows())
    df = pd.DataFrame([r for r, _, _ in res])
    f_mod = res[0][1]
    modspec = np.array([p for _, _, p in res])

    # ---------------- B1 label audit
    cols = ["key", "ds", "subject", "trial", "sh_label", "az_onset", "az_values", "label_matches_onset",
            "frac_samples_label_wrong_direction", "col0_stream", "frac_col0_attended", "n_speaker_switches",
            "n_direction_switches", "direction_switch_s", "cond", "orig_pos", "wav_col0", "wav_col1", "dur_s"]
    df[cols].to_csv(os.path.join(TAB, "label_audit.csv"), index=False)
    summ = df.groupby("ds", observed=True).agg(
        trials=("key", "size"), subjects=("subject", "nunique"),
        label_matches_onset=("label_matches_onset", "mean"),
        trials_with_speaker_switch=("n_speaker_switches", lambda s: int((s > 0).sum())),
        speaker_switches=("n_speaker_switches", "sum"),
        trials_with_direction_switch=("n_direction_switches", lambda s: int((s > 0).sum())),
        direction_switches=("n_direction_switches", "sum"),
        frac_direction_samples_label_wrong=("frac_samples_label_wrong_direction", "mean"),
        frac_col0_attended=("frac_col0_attended", "mean"),
        col0_is_cnd_stream1=("col0_stream", lambda s: float((s == 1).mean())))
    summ.to_csv(os.path.join(TAB, "label_audit_summary.csv"))
    log.info("\n" + summ.to_string())

    # ---------------- B4 envelope asymmetry
    rows = []
    for ds in DS_KEYS:
        d = df[df.ds == ds]
        k = int((d.sd_ratio > 1).sum())
        n = len(d)
        subj = d.groupby("subject").sd_ratio.apply(lambda s: np.mean(np.log(s)))
        rows.append(dict(ds=ds, n_trials=n, n_subjects=d.subject.nunique(), share_col0_larger_sd=k / n,
                         binom_p=stats.binomtest(k, n, 0.5).pvalue,
                         wilcoxon_trial_logratio_p=stats.wilcoxon(np.log(d.sd_ratio)).pvalue,
                         median_sd_ratio=float(np.median(d.sd_ratio)),
                         share_col0_more_1_9=float(d.col0_more_1_9.mean()),
                         binom_p_1_9=stats.binomtest(int(d.col0_more_1_9.sum()), n, 0.5).pvalue,
                         subj_share_col0_larger=float((subj > 0).mean()),
                         wilcoxon_subject_p=(stats.wilcoxon(subj).pvalue if len(subj) > 5 else np.nan),
                         n_distinct_ratio_levels=int(np.unique(np.round(d.sd_ratio, 4)).size),
                         n_distinct_col0_sd=int(np.unique(np.round(d.sd0, 6)).size),
                         n_distinct_stim_pairs=int(d[["wav_col0", "wav_col1"]].drop_duplicates().shape[0])))
    asym = pd.DataFrame(rows)
    asym.to_csv(os.path.join(TAB, "env_asymmetry_summary.csv"), index=False)
    log.info("\n" + asym.to_string())
    df[["key", "ds", "subject", "trial", "sd0", "sd1", "sd_ratio", "p19_0", "p19_1", "col0_more_1_9",
        "r_streams"]].to_csv(os.path.join(TAB, "env_asymmetry_trials.csv"), index=False)
    fig, ax = plt.subplots(figsize=(7, 3.5))
    for i, ds in enumerate(DS_KEYS):
        v = np.log2(df[df.ds == ds].sd_ratio)
        ax.scatter(i + (np.random.default_rng(0).random(len(v)) - 0.5) * 0.5, v, s=4, color=COLORS[ds], alpha=0.5)
        ax.plot([i - 0.3, i + 0.3], [np.median(v)] * 2, "k-")
    ax.axhline(0, color="gray", lw=0.8)
    ax.set_xticks(range(len(DS_KEYS)), [f"{LABELS[d]}\n(n={int((df.ds == d).sum())})" for d in DS_KEYS])
    ax.set_ylabel("log2 SD(col0)/SD(col1)")
    ax.set_title("Envelope SD ratio, attended (col0) vs ignored (col1); one dot per trial")
    savefig(fig, "b4_env_sd_ratio", df[["key", "ds", "sd_ratio"]])

    loud = loud_column_classifier(df)
    loud.to_csv(os.path.join(TAB, "env_loud_column_classifier_per_subject.csv"), index=False)
    ls = []
    for (sch, ds), g in loud.groupby(["scheme", "ds"]):
        m, lo, hi = boot_ci(g.acc.values)
        ls.append(dict(scheme=sch, ds=ds, n_subjects=len(g), median_acc=m, ci_lo=lo, ci_hi=hi,
                       wilcoxon_vs_0p5=stats.wilcoxon(g.acc - 0.5).pvalue if (g.acc != 0.5).sum() > 5 else np.nan))
    ls = pd.DataFrame(ls)
    ls.to_csv(os.path.join(TAB, "env_loud_column_classifier.csv"), index=False)
    log.info("\n" + ls.to_string())

    # ---------------- B5 design confounds (label vs parity / order)
    rows = []
    for ds in DS_KEYS:
        d = df[df.ds == ds].copy()
        side = np.sign(d.az_onset)
        par = d.trial % 2
        ct = pd.crosstab(par, side)
        agree = float(np.mean((par == 1) == (side < 0)))
        rows.append(dict(ds=ds, n=len(d), share_left=float((side < 0).mean()),
                         agree_odd_is_left=agree, parity_locked=bool(agree in (0.0, 1.0)),
                         chi2_p=stats.chi2_contingency(ct)[1] if ct.shape == (2, 2) else np.nan,
                         subjects_fully_parity_locked=int(d.assign(a=(par == 1) == (side < 0)).groupby("subject").a
                                                          .agg(lambda s: s.all() or (~s).all()).sum()),
                         n_subjects=d.subject.nunique(),
                         spearman_trialidx_left_r=stats.spearmanr(d.trial, side < 0)[0],
                         spearman_trialidx_left_p=stats.spearmanr(d.trial, side < 0)[1],
                         spearman_origpos_left_r=(stats.spearmanr(d.orig_pos, side < 0)[0] if (d.orig_pos > 0).all()
                                                  else np.nan)))
    par = pd.DataFrame(rows)
    par.to_csv(os.path.join(TAB, "design_parity.csv"), index=False)
    log.info("\n" + par.to_string())
    # label by trial position (share left per trial index)
    pos = df.assign(left=(np.sign(df.az_onset) < 0).astype(int)).groupby(["ds", "trial"], observed=True).left.mean()
    pos.reset_index().to_csv(os.path.join(TAB, "design_order.csv"), index=False)

    # ---------------- B7 envelope character
    ec = df.groupby("ds", observed=True).agg(
        mean_mean=("mean0", "median"), sd_median=("sd0", "median"), frac_neg=("frac_neg0", "median"),
        min_min=("min0", "min"), max_max=("max0", "max"), kurt=("kurt0", "median"), skew=("skew0", "median"),
        frac_trials_zscored=("mean0", lambda s: float(np.mean((np.abs(s) < 0.05) & (np.abs(df.loc[s.index, "sd0"] - 1) < 0.05)))),
        r_streams_median=("r_streams", "median"), r_streams_iqr_lo=("r_streams", lambda s: s.quantile(0.25)),
        r_streams_iqr_hi=("r_streams", lambda s: s.quantile(0.75)))
    ec.to_csv(os.path.join(TAB, "env_character.csv"))
    log.info("\n" + ec.to_string())
    fig, ax = plt.subplots(figsize=(6, 4))
    ms = []
    for ds in DS_KEYS:
        m = (df.ds == ds).values
        p = np.median(modspec[m], 0)
        p = p / p[(f_mod > 0.5) & (f_mod < 20)].sum()
        ax.loglog(f_mod[1:], p[1:], color=COLORS[ds], label=f"{LABELS[ds]} (n={m.sum()} trials)")
        ms.append(pd.DataFrame(dict(ds=ds, f=f_mod, p=p)))
    ax.set_xlabel("modulation frequency (Hz)")
    ax.set_ylabel("normalised power (median over trials)")
    ax.legend(fontsize=7)
    ax.set_title("Envelope modulation spectrum, column 0")
    savefig(fig, "b7_env_modspec", pd.concat(ms))

    # ---------------- B6 stimulus reuse
    long = pd.concat([df[["key", "ds", "subject", "trial", "wav_col0"]].rename(columns={"wav_col0": "wav"}).assign(col=0),
                      df[["key", "ds", "subject", "trial", "wav_col1"]].rename(columns={"wav_col1": "wav"}).assign(col=1)])
    use = long.groupby(["ds", "wav"], observed=True).agg(n_uses=("key", "size"), n_subjects=("subject", "nunique"),
                                                         as_attended=("col", lambda s: int((s == 0).sum()))).reset_index()
    use.to_csv(os.path.join(TAB, "stim_reuse_by_name.csv"), index=False)
    rs = use.groupby("ds", observed=True).agg(n_unique_wavs=("wav", "size"), max_uses=("n_uses", "max"),
                                              median_uses=("n_uses", "median"),
                                              max_subjects=("n_subjects", "max"))
    xs = set(use[use.ds == "KUL"].wav) & set(use[use.ds == "UHD"].wav)
    rs.to_csv(os.path.join(TAB, "stim_reuse_summary.csv"))
    log.info("\n" + rs.to_string() + f"\nKUL2016 & KUL-UHD shared wav names: {len(xs)} {sorted(xs)[:10]}")

    # envelope fingerprint on one exemplar per unique (dataset, wav name), 8 Hz
    ex = long.drop_duplicates(["ds", "wav"]).reset_index(drop=True)
    env8 = []
    for _, r in ex.iterrows():
        e = load_env(r["key"])[:, r["col"]].astype(float)
        e = signal.resample_poly(e - e.mean(), 1, 16)
        env8.append(e)
    log.info(f"fingerprinting {len(env8)} unique envelopes")
    n = 20 * 8
    snips = []
    for x in env8:
        # snippet from the middle of the envelope (the first minute can hold near-flat intros)
        s0 = max(0, len(x) // 2 - n // 2)
        s = x[s0:s0 + n]
        snips.append((s - s.mean()) / s.std() if len(s) == n and s.std() > 1e-6 * (np.abs(x).mean() + 1e-12) else np.zeros(n))
    S = np.array([s if len(s) == n else np.zeros(n) for s in snips])

    def _col(j):
        y = env8[j]
        if len(y) < n:
            return np.zeros(len(S), np.float32)
        cs, cs2 = np.cumsum(np.r_[0, y]), np.cumsum(np.r_[0, y ** 2])
        mu = (cs[n:] - cs[:-n]) / n
        sd = np.sqrt(np.maximum((cs2[n:] - cs2[:-n]) / n - mu ** 2, 0))
        sd = np.where(sd > 0.05 * np.median(sd), sd, np.inf)      # ignore near-flat target windows
        L = len(y) + n
        C = np.fft.irfft(np.fft.rfft(y, L)[None, :] * np.conj(np.fft.rfft(S, L, axis=1)), L, axis=1)[:, : len(y) - n + 1]
        return (C / (n * sd[None, :])).max(1).astype(np.float32)

    M = np.column_stack(Parallel(n_jobs=4)(delayed(_col)(j) for j in range(len(env8))))
    np.save(os.path.join(TAB, "..", "cache", "stim_fingerprint_matrix.npy"), M)
    ex.to_csv(os.path.join(TAB, "..", "cache", "stim_fingerprint_items.csv"), index=False)
    pairs = []
    for i in range(len(ex)):
        for j in range(len(ex)):
            if i != j and M[i, j] > 0.8:
                pairs.append(dict(ds_a=ex.ds[i], wav_a=ex.wav[i], ds_b=ex.ds[j], wav_b=ex.wav[j], max_ncc=float(M[i, j])))
    pairs = pd.DataFrame(pairs)
    pairs.to_csv(os.path.join(TAB, "stim_reuse_fingerprint_pairs.csv"), index=False)
    if len(pairs):
        cross = pairs.groupby(["ds_a", "ds_b"]).size()
        log.info("fingerprint pairs with max NCC > 0.8 (snippet of A found inside B):\n" + cross.to_string())
    log.info("done")
