"""Evaluate reconstructions: windowed accuracy, whole-trial correlations, 1-s evidence, SNR_1.

Usage: c3_windows.py <cfg> [scheme ...]      (default: every scheme directory present)
Writes
  cache/eval/<cfg>/<scheme>.parquet      per trial x lag x window length: n windows, n correct
  cache/eval/<cfg>/<scheme>_trial.parquet per trial x lag: whole-trial r(col0), r(col1); 1-s evidence sums
  cache/evidence/<cfg>/<scheme>/<lag>/<key>.npz   1-s windows at 0.25-s hop: r0, r1, t_end (s), att
Window w [s, s+W) uses reconstructions yhat[s..s+W-1], i.e. EEG up to (s+W-1+L)/fs: its decision is
stamped at the window end, so the lookahead is the decoder lag L (<= 0.5 s).
"""
import glob
import os
import sys

import numpy as np
import pandas as pd
from joblib import Parallel, delayed

sys.path.insert(0, os.path.dirname(__file__))
from common import CACHE, CFG, get_logger, trial_index  # noqa: E402

WINS = CFG["decoder"]["windows_s"]
HOP = CFG["decoder"]["evidence_hop_s"]


def win_corr_blocks(y, E, W):
    """Non-overlapping windows. y (n,), E (n,2) -> r (nw, 2)."""
    nw = len(y) // W
    if nw == 0:
        return np.zeros((0, 2))
    Y = y[: nw * W].reshape(nw, W)
    Y = Y - Y.mean(1, keepdims=True)
    out = np.zeros((nw, 2))
    for c in (0, 1):
        X = E[: nw * W, c].reshape(nw, W)
        X = X - X.mean(1, keepdims=True)
        out[:, c] = (X * Y).sum(1) / np.sqrt((X ** 2).sum(1) * (Y ** 2).sum(1) + 1e-30)
    return out


def win_corr_sliding(y, E, W, H):
    """Windows of W samples every H samples via cumulative sums. Returns r (nw,2), starts."""
    n = len(y)
    starts = np.arange(0, n - W + 1, H)
    if len(starts) == 0:
        return np.zeros((0, 2)), starts

    def csum(a):
        return np.concatenate([[0.0], np.cumsum(a)])

    Sy, Syy = csum(y), csum(y * y)
    sy = Sy[starts + W] - Sy[starts]
    syy = Syy[starts + W] - Syy[starts]
    vy = syy - sy ** 2 / W
    out = np.zeros((len(starts), 2))
    for c in (0, 1):
        x = E[:, c]
        Sx, Sxx, Sxy = csum(x), csum(x * x), csum(x * y)
        sx = Sx[starts + W] - Sx[starts]
        sxx = Sxx[starts + W] - Sxx[starts]
        sxy = Sxy[starts + W] - Sxy[starts]
        out[:, c] = (sxy - sx * sy / W) / np.sqrt(np.maximum((sxx - sx ** 2 / W) * vy, 1e-30))
    return out, starts


def majority(a, W, starts=None):
    if starts is None:
        nw = len(a) // W
        return (a[: nw * W].reshape(nw, W).mean(1) > 0.5).astype(int)
    c = np.concatenate([[0], np.cumsum(a)])
    return ((c[starts + W] - c[starts]) / W > 0.5).astype(int)


def eval_trial(cfg, scheme, key, seg=None):
    z = np.load(os.path.join(CACHE, "recon", cfg, scheme, f"{key}.npz"))
    e = np.load(os.path.join(CACHE, "recon", cfg, "_env", f"{key}.npz"))
    fs, t0 = int(e["fs"]), float(e["t0"])
    rows, trows = [], []
    for lag in z.files:
        y = z[lag].astype(float)
        n = len(y)
        E = e["env"][:n].astype(float)
        att = e["att"][:n].astype(int)
        off = 0
        if seg is not None:                          # cross-half: restrict to one half
            a, b = seg
            a, b = max(a, 0), min(b, n)
            y, E, att, off = y[a:b], E[a:b], att[a:b], a
        for w in WINS:
            W = int(w * fs)
            r = win_corr_blocks(y, E, W)
            lab = majority(att, W)
            dec = (r[:, 1] > r[:, 0]).astype(int)
            rows.append(dict(key=key, lag=lag, w=w, n_win=len(r), n_correct=int((dec == lab).sum()),
                             n_col0=int((dec == 0).sum())))
        # 1-s evidence, non-overlapping: d = r_att - r_ign
        r1 = win_corr_blocks(y, E, fs)
        lab1 = majority(att, fs)
        d = np.where(lab1 == 0, r1[:, 0] - r1[:, 1], r1[:, 1] - r1[:, 0])
        rr = np.corrcoef(np.c_[y, E].T)
        trows.append(dict(key=key, lag=lag, r_col0=rr[0, 1], r_col1=rr[0, 2], n=len(y), n1=len(d),
                          sum_d=float(d.sum()), sum_d2=float((d ** 2).sum()), sum_r0=float(r1[:, 0].sum()),
                          sum_r1=float(r1[:, 1].sum())))
        if seg is None:
            rs, st = win_corr_sliding(y, E, fs, int(HOP * fs))
            p = os.path.join(CACHE, "evidence", cfg, scheme, lag, f"{key}.npz")
            os.makedirs(os.path.dirname(p), exist_ok=True)
            np.savez(p, r0=rs[:, 0].astype(np.float32), r1=rs[:, 1].astype(np.float32),
                     t_end=((st + fs + off) / fs + t0).astype(np.float32), att=majority(att, fs, st).astype(np.int8),
                     fs=fs, t0=t0, L_s=float(lag.split("-")[1][:-2]) / 1000.0)
    return rows, trows


def eval_crosshalf(cfg, scheme, key):
    e = np.load(os.path.join(CACHE, "recon", cfg, "_env", f"{key}.npz"))
    fs, t0 = int(e["fs"]), float(e["t0"])
    h = int(round((300.0 - t0) * fs))
    L = int(round(0.5 * fs))
    seg = (h, 10 ** 9) if scheme == "xh_h1" else (0, h - L)
    return eval_trial(cfg, scheme, key, seg)


if __name__ == "__main__":
    cfg = sys.argv[1]
    schemes = sys.argv[2:] or sorted(os.path.basename(p) for p in glob.glob(os.path.join(CACHE, "recon", cfg, "*"))
                                     if not os.path.basename(p).startswith("_"))
    log = get_logger(f"c3_{cfg}")
    ti = trial_index()
    os.makedirs(os.path.join(CACHE, "eval", cfg), exist_ok=True)
    for sc in schemes:
        keys = sorted(os.path.basename(p)[:-4] for p in glob.glob(os.path.join(CACHE, "recon", cfg, sc, "dataset-*.npz")))
        fn = eval_crosshalf if sc.startswith("xh_") else eval_trial
        res = Parallel(n_jobs=CFG["n_jobs"])(delayed(fn)(cfg, sc, k) for k in keys)
        df = pd.DataFrame([r for rs, _ in res for r in rs]).merge(ti[["key", "ds", "subject", "subj_uid"]], on="key")
        tr = pd.DataFrame([r for _, rs in res for r in rs]).merge(ti[["key", "ds", "subject", "subj_uid"]], on="key")
        df.to_parquet(os.path.join(CACHE, "eval", cfg, f"{sc}.parquet"))
        tr.to_parquet(os.path.join(CACHE, "eval", cfg, f"{sc}_trial.parquet"))
        acc = df.groupby(["lag", "w", "ds"], observed=True).apply(
            lambda g: g.groupby("subject").apply(lambda s: s.n_correct.sum() / max(s.n_win.sum(), 1)).median())
        log.info(f"{cfg} {sc}: {len(keys)} trials; median subject accuracy\n" + acc.unstack("ds").round(3).to_string())
