"""Build filtered + decimated caches for the decoding phases.

For each trial and variant writes cache/pp/<variant>/<key>.npz with
  eeg  (T', 64) float32  B64-ordered channels (missing channels = 0, see `present`), per-channel LTI
                         filtering only (CAR and running z-score are applied at load time per montage,
                         valid because CAR commutes with identical per-channel LTI filters)
  env  (T', 2)  float32  same filter chain applied to the two SuperHuge envelope columns
  present (64,) bool
Variants: c19 = causal HP0.5 -> BP1-9 -> AA12 -> 32 Hz;  z19 = same, zero-phase (sosfiltfilt);
          cwide = causal HP0.5 -> LP30 -> 64 Hz.
The supplied 32 Hz preprocessed data are read directly from data/superhuge/preprocessed at load time.
"""
import os
import sys

import numpy as np
from joblib import Parallel, delayed

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

log = get_logger("c0_cache_pp")
VARIANTS = ["c19", "z19", "cwide"]


def build(row, variants):
    key = row["key"]
    todo = [v for v in variants if not os.path.exists(os.path.join(CACHE, "pp", v, f"{key}.npz"))]
    if not todo:
        return 0
    src, present = b64_idx(row)
    raw = load_eeg(key)
    x = np.zeros((raw.shape[0], 64))
    x[:, present] = np.asarray(raw[:, src[present]], dtype=np.float64)
    e = load_env(key).astype(np.float64)
    for v in todo:
        y, _ = filter_chain(x, v)
        ey, _ = filter_chain(e, v)
        os.makedirs(os.path.join(CACHE, "pp", v), exist_ok=True)
        np.savez(os.path.join(CACHE, "pp", v, f"{key}.npz"), eeg=y.astype(np.float32),
                 env=ey.astype(np.float32), present=present)
    return len(todo)


if __name__ == "__main__":
    ti = trial_index()
    if len(sys.argv) > 1 and sys.argv[1] == "dry":
        ti = ti[ti.subject == ti.groupby("ds", observed=True).subject.transform("min")]
    n = Parallel(n_jobs=CFG["n_jobs"])(delayed(build)(r, VARIANTS) for _, r in ti.iterrows())
    log.info(f"built {sum(n)} trial-variants over {len(ti)} trials")
