"""B1 external caches for prep wb16P_n5_t60 (causal 0.5–16 Hz → 32 Hz + eaP).

Corpus is built by prepare_data.py from EDA cwide. This script builds matching caches for
AASD / Carta2026 / Fuglsang2020 from their raw-or-wide sources (no 1–9 filtfilt narrowing).

  AASD:      Processed EEG @128 Hz → causal HP0.5 + LP16 → ::4 → montage/CAR → z → eaP (no carry)
  Carta2026: ICA 0.5–20 @64 Hz → causal LP16 → ::2 → montage/CAR → z → eaP (no carry)
  Fuglsang:  stage_a @128 Hz → causal HP0.5 + LP16 → ::4 → CAR → z → eaP (no carry; train-only)

usage: python -u b1_wb16_build_ext.py [AASD Carta2026 Fuglsang2020]
"""
from __future__ import annotations

import glob
import os
import sys

import numpy as np
import pandas as pd
import scipy.io as sio
from joblib import Parallel, delayed
from scipy.io import wavfile
from scipy.signal import butter, resample_poly, sosfilt

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = "/root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset"
EXT = os.path.join(ROOT, "experiments", "external_data")
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.join(ROOT, "reports", "eda_full", "scripts"))
sys.path.insert(0, os.path.join(ROOT, "experiments", "envelope_reverse"))

from common import MONTAGES  # noqa: E402
from prepare_data import CFG, causal_ea, ea_prior, zscore_trial  # noqa: E402
from reverse import candidates  # noqa: E402

PREP = "wb16P_n5_t60"
P = CFG["preps"][PREP]
FS, FS0, TRIM = CFG["fs"], 128, 32
MONT = [c.upper() for c in MONTAGES["b64ustc58"]]
HP = butter(2, 0.5, "highpass", fs=FS0, output="sos")
LP16_128 = butter(6, 16.0, "lowpass", fs=FS0, output="sos")
LP16_64 = butter(6, 16.0, "lowpass", fs=64, output="sos")


def causal_wb16_128(x):
    """Causal 0.5–16 Hz then decimate 128→32."""
    x = np.asarray(x, np.float64)
    y = sosfilt(HP, x, axis=0)
    y = sosfilt(LP16_128, y, axis=0)
    return y[:: FS0 // FS]


def ea_nocarry(x):
    return causal_ea(x, FS, tau_s=P.get("ea_tau", 60.0), R0=ea_prior(P, x), n0=P.get("ea_n0"),
                     shrink=P.get("ea_shrink", 0.1))


# ── AASD ────────────────────────────────────────────────────────────────────
AASD = os.path.join(EXT, "AASD")
CNT = ['FP1', 'FPZ', 'FP2', 'AF3', 'AF4', 'F7', 'F5', 'F3', 'F1', 'FZ', 'F2', 'F4', 'F6', 'F8', 'FT7', 'FC5', 'FC3', 'FC1',
       'FCZ', 'FC2', 'FC4', 'FC6', 'FT8', 'T7', 'C5', 'C3', 'C1', 'CZ', 'C2', 'C4', 'C6', 'T8', 'M1', 'TP7', 'CP5', 'CP3',
       'CP1', 'CPZ', 'CP2', 'CP4', 'CP6', 'TP8', 'M2', 'P7', 'P5', 'P3', 'P1', 'PZ', 'P2', 'P4', 'P6', 'P8', 'PO7', 'PO5',
       'PO3', 'POZ', 'PO4', 'PO6', 'PO8', 'CB1', 'O1', 'OZ', 'O2', 'CB2']
CH62 = [c for c in CNT if c not in ("M1", "M2")]


def aasd_envelope(code):
    cp = os.path.join(AASD, "cache", "env_wb16", f"mixed_{code - 10:03d}.npy")
    if os.path.exists(cp):
        return np.load(cp)
    fs, a = wavfile.read(os.path.join(AASD, "extract", "Stimuli Audio", f"mixed_{code - 10:03d}.wav"))
    # candidates() already returns gammatone^0.6 at 128 Hz (same as convert_aasd.py)
    e = np.stack([candidates(a[:, c].astype(np.float64), fs)["gt_pow06"] for c in range(2)], 1)
    e = causal_wb16_128(e)  # → 32 Hz
    os.makedirs(os.path.dirname(cp), exist_ok=True)
    np.save(cp + ".tmp.npy", e)
    os.replace(cp + ".tmp.npy", cp)
    return e


def aasd_subject(s):
    d = sio.loadmat(os.path.join(AASD, "extract", "Processed EEG", f"S{s}", f"S{s}.mat"),
                    squeeze_me=True, struct_as_record=False)["EEG_new"]
    start, presses = {}, {}
    for r in d.event:
        c, lat, e = int(float(r[0])), float(r[1]), int(float(r[4]))
        if c in (179, 184):
            presses.setdefault(e, []).append((lat - (e - 1) * d.data.shape[1] - 1, c))
        else:
            start.setdefault(e, c)
    sel = [CH62.index(c) if c in CH62 else -1 for c in MONT]
    out = os.path.join(AASD, "cache", PREP)
    os.makedirs(out, exist_ok=True)
    rows = []
    for t in range(1, 51):
        key = f"AASD_S{s:02d}_T{t:02d}"
        path = os.path.join(out, key + ".npz")
        if os.path.exists(path):
            continue
        x128 = d.data[:, :, t - 1].T.astype(np.float64)  # (7680, 62)
        n128 = len(x128)
        x = causal_wb16_128(x128)
        eeg = np.zeros((len(x), len(MONT)))
        pres = np.array([i >= 0 for i in sel])
        eeg[:, pres] = x[:, [i for i in sel if i >= 0]]
        eeg[:, pres] -= eeg[:, pres].mean(1, keepdims=True)
        eeg = zscore_trial(eeg)
        eeg = ea_nocarry(eeg)
        env = aasd_envelope(start[t])[: n128 // (FS0 // FS)]  # 32 Hz, trial-length
        pr = sorted(presses.get(t, []))
        att128 = np.zeros(n128, np.int8)
        if pr:
            att128[:] = 0 if pr[0][1] == 179 else 1
            for lat, c in pr:
                att128[max(0, int(round(lat))):] = 0 if c == 179 else 1
        att = att128[:: FS0 // FS][: min(len(eeg), len(env))]
        n = min(len(eeg), len(env), len(att))
        np.savez(path, eeg=eeg[TRIM:n - TRIM].astype(np.float32),
                 env=zscore_trial(env[:n])[TRIM:n - TRIM].astype(np.float32),
                 att=att[TRIM:n - TRIM], t0=TRIM / FS, att128=att128, n128=n128)
        rows.append(key)
    return rows


def build_aasd():
    subs = sorted(int(f[1:]) for f in os.listdir(os.path.join(AASD, "extract", "Processed EEG")) if f.startswith("S"))
    Parallel(n_jobs=4)(delayed(aasd_envelope)(code) for code in range(11, 71))
    built = sum(Parallel(n_jobs=3)(delayed(aasd_subject)(s) for s in subs), [])
    n = len([f for f in os.listdir(os.path.join(AASD, "cache", PREP)) if f.endswith(".npz")])
    print(f"AASD [{PREP}]: {n} trials (new keys this run {len(built)})", flush=True)


# ── Carta2026 ───────────────────────────────────────────────────────────────
CAR = os.path.join(EXT, "Carta2026")
D = os.path.join(CAR, "extract", "Carta_et_al_2026", "Data")
START_ATT = [1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1]


def loadmat_any(f):
    try:
        return sio.loadmat(f, squeeze_me=True, struct_as_record=False)
    except NotImplementedError:
        import mat73
        return mat73.loadmat(f)


def carta_envelope(trial):
    cp = os.path.join(CAR, "cache", "env_wb16", f"Audio_{trial:03d}.npy")
    if os.path.exists(cp):
        return np.load(cp)
    fs, a = wavfile.read(os.path.join(D, "STIM", "Audio", f"Audio_{trial:03d}.wav"))
    a = a[5 * fs:].astype(np.float64)
    # candidates() already returns 128 Hz envelopes
    e = np.stack([candidates(a[:, c], fs)["gt_pow06"] for c in range(2)], 1)
    e = causal_wb16_128(e)
    os.makedirs(os.path.dirname(cp), exist_ok=True)
    np.save(cp + ".tmp.npy", e)
    os.replace(cp + ".tmp.npy", cp)
    return e


def carta_labels(trial, n128, switches):
    sw = [t for t in np.atleast_1d(switches[trial - 1]) if np.isfinite(t) and t > 0]
    att = np.zeros(n128, np.int8)
    cur = 0 if START_ATT[trial - 1] == 1 else 1
    prev = 0
    for t in sw:
        s = min(n128, int(round(t * 128)))
        att[prev:s] = cur
        cur, prev = 1 - cur, s
    att[prev:] = cur
    return att


def carta_subject(f, switches):
    s = int(os.path.basename(f)[-7:-4])
    d = loadmat_any(f)["eeg"]
    get = (lambda k: getattr(d, k)) if hasattr(d, "_fieldnames") else (lambda k: d[k])
    fs = int(np.ravel(get("fs"))[0])
    labs = [str(getattr(c, "labels", c)).strip().upper() for c in np.atleast_1d(get("chanlocs"))] if np.size(get("chanlocs")) else []
    sel = [labs.index(c) if c in labs else -1 for c in MONT]
    pres = np.array([i >= 0 for i in sel])
    out = os.path.join(CAR, "cache", PREP)
    os.makedirs(out, exist_ok=True)
    rows = []
    for t, x in enumerate(np.atleast_1d(get("data")), start=1):
        key = f"CAR_S{s:02d}_T{t:02d}"
        path = os.path.join(out, key + ".npz")
        if os.path.exists(path):
            continue
        x = np.asarray(x, np.float64)
        if x.shape[0] < x.shape[1]:
            x = x.T
        # source is already 0.5–20 @64 Hz (or similar); causal LP16 then ::2 → 32
        assert fs == 64, fs
        x = sosfilt(LP16_64, x, axis=0)[::2]
        eeg = np.zeros((len(x), len(MONT)))
        eeg[:, pres] = x[:, [i for i in sel if i >= 0]]
        eeg[:, ~pres] = 0.0
        eeg[:, pres] -= eeg[:, pres].mean(1, keepdims=True)
        eeg = zscore_trial(eeg)
        eeg = ea_nocarry(eeg)
        env = carta_envelope(t)  # 32 Hz
        n128 = min(len(env) * 4, len(eeg) * 4)
        att128 = carta_labels(t, n128, switches)
        att = att128[::4][: min(len(eeg), len(env))]
        n = min(len(eeg), len(env), len(att))
        np.savez(path, eeg=eeg[TRIM:n - TRIM].astype(np.float32),
                 env=zscore_trial(env[:n])[TRIM:n - TRIM].astype(np.float32),
                 att=att[TRIM:n - TRIM], t0=TRIM / FS, att128=att128[:n128], n128=n128)
        rows.append(key)
    return rows


def build_carta():
    switches = sio.loadmat(os.path.join(D, "MAIN", "attentionSwitches.mat"))["attentionSwitches"]
    Parallel(n_jobs=4)(delayed(carta_envelope)(t) for t in range(1, 21))
    files = sorted(glob.glob(os.path.join(D, "MAIN", "dataCND", "ica_pre_05-20Hz_64fs_dataSub*.mat")))
    built = sum(Parallel(n_jobs=3)(delayed(carta_subject)(f, switches) for f in files), [])
    n = len([f for f in os.listdir(os.path.join(CAR, "cache", PREP)) if f.endswith(".npz")])
    print(f"Carta2026 [{PREP}]: {n} trials (new {len(built)})", flush=True)


# ── Fuglsang2020 ────────────────────────────────────────────────────────────
FUG = os.path.join(EXT, "Fuglsang2020")
DER = os.path.join(FUG, "extract", "ds-eeg-snhl", "derivatives", "stimuli")


def fug_envelope(stim_file):
    base = os.path.join(DER, os.path.splitext(stim_file)[0])
    f = base + "woa.mat" if os.path.exists(base + "woa.mat") else base + ".mat"
    d = sio.loadmat(f, squeeze_me=True, struct_as_record=False)["dat"]
    fs = int(np.ravel(d.fs)[0])
    e = resample_poly(np.ravel(d.feat).astype(np.float64), FS0, fs)
    return causal_wb16_128(e)  # → 32 Hz


def fug_subject(files):
    out = os.path.join(FUG, "cache", PREP)
    os.makedirs(out, exist_ok=True)
    rows = []
    for f in files:
        key = "FUG_" + os.path.basename(f)[:-4]
        path = os.path.join(out, key + ".npz")
        if os.path.exists(path):
            continue
        z = np.load(f, allow_pickle=True)
        present = z["present"]
        x = causal_wb16_128(z["eeg"].astype(np.float64))
        x[:, present] -= x[:, present].mean(1, keepdims=True)
        x[:, ~present] = 0.0
        x = zscore_trial(x)
        x = ea_nocarry(x)
        et = fug_envelope(str(z["target_file"]))
        em = fug_envelope(str(z["masker_file"]))
        dly = int(round(float(z["masker_delay_s"]) * FS))  # samples @32 Hz
        em = np.concatenate([np.zeros(max(dly, 0)), em])[max(-dly, 0):]
        n = min(len(x), len(et), len(em))
        e = np.stack([et[:n], em[:n]], 1)
        np.savez(path, eeg=x[TRIM:n - TRIM].astype(np.float32),
                 env=zscore_trial(e[:n])[TRIM:n - TRIM].astype(np.float32),
                 att=np.zeros(n - 2 * TRIM, np.int8), t0=TRIM / FS)
        rows.append(key)
    return rows


def build_fug():
    files = sorted(glob.glob(os.path.join(FUG, "stage_a", "*.npz")))
    subs = sorted({os.path.basename(f).split("_")[0] for f in files})
    built = sum(Parallel(n_jobs=4)(
        delayed(fug_subject)([f for f in files if os.path.basename(f).startswith(s + "_")]) for s in subs), [])
    n = len([f for f in os.listdir(os.path.join(FUG, "cache", PREP)) if f.endswith(".npz")])
    print(f"Fuglsang2020 [{PREP}]: {n} trials (new {len(built)})", flush=True)


if __name__ == "__main__":
    sets = sys.argv[1:] or ["AASD", "Carta2026", "Fuglsang2020"]
    # ensure Fuglsang prior readable from EXP cache
    prior_src = os.path.join(ROOT, "experiments", "decoder_lodo", "cache", "ea_prior_fug.npy")
    prior_dst = os.path.join(HERE, "cache", "ea_prior_fug.npy")
    if os.path.exists(prior_src) and not os.path.exists(prior_dst):
        os.makedirs(os.path.dirname(prior_dst), exist_ok=True)
        os.symlink(prior_src, prior_dst)
    for name in sets:
        if name == "AASD":
            build_aasd()
        elif name == "Carta2026":
            build_carta()
        elif name == "Fuglsang2020":
            build_fug()
        else:
            raise SystemExit(f"unknown set {name}")
