"""Phase A pass over every raw trial (128 Hz, all stored channels).

Per trial writes
  cache/qc/<key>.parquet      one row per channel: DC, SD, robust SD, RMS, RMS/SD, drift, kurtosis,
                              outlier fraction, largest jump (+ timing), edge-jump size (robust-SD units),
                              per-channel band powers
  cache/qcpsd/<key>.npz       median-over-channels Welch PSD, 1-s alpha power (common57, CAR),
                              hEOG proxy and true EOG channels at 4 Hz (zero-phase LP 1 Hz)
Usage: a1_qc.py [dry]      (dry = first subject of every dataset)
"""
import os
import sys

import numpy as np
import pandas as pd
from joblib import Parallel, delayed
from scipy import signal, stats

sys.path.insert(0, os.path.dirname(__file__))
from common import (CACHE, CFG, FS, MONTAGES, get_logger, load_eeg, load_labels, montage_idx,  # noqa: E402
                    sos_bp, sos_lp, trial_index)

Q = CFG["qc"]
D1 = os.path.join(CACHE, "qc")
D2 = os.path.join(CACHE, "qcpsd")
os.makedirs(D1, exist_ok=True)
os.makedirs(D2, exist_ok=True)
log = get_logger("a1_qc")

HEOG_L = ["AF7", "F7", "FT7"]
HEOG_R = ["AF8", "F8", "FT8"]


def qc_trial(row):
    key = row["key"]
    f1, f2 = os.path.join(D1, f"{key}.parquet"), os.path.join(D2, f"{key}.npz")
    if os.path.exists(f1) and os.path.exists(f2):
        return key, "cached"
    x = np.asarray(load_eeg(key), dtype=np.float64)          # (T, C)
    T, C = x.shape
    names = row["channels"].split("|")
    t_min = np.arange(T) / FS / 60.0
    mean = x.mean(0)
    sd = x.std(0)
    med = np.median(x, 0)
    rsd = 1.4826 * np.median(np.abs(x - med), 0)
    rms = np.sqrt((x ** 2).mean(0))
    tc = t_min - t_min.mean()
    slope = (tc[:, None] * (x - mean)).sum(0) / (tc ** 2).sum()
    kurt = stats.kurtosis(x, axis=0, fisher=True, bias=True)
    frac_out = (np.abs(x - med) > Q["outlier_rsd"] * np.maximum(rsd, 1e-12)).mean(0)
    dx = np.abs(np.diff(x, axis=0))
    jmax_i = dx.argmax(0)
    jmax = dx[jmax_i, np.arange(C)]
    d_rsd = 1.4826 * np.median(np.abs(np.diff(x, axis=0) - np.median(np.diff(x, axis=0), 0)), 0)
    ne = int(Q["edge_window_s"] * FS)
    edge_start = dx[:ne].max(0) / np.maximum(d_rsd, 1e-12)
    edge_end = dx[-ne:].max(0) / np.maximum(d_rsd, 1e-12)

    # Welch PSD per channel (4-s Hann, 50 % overlap), constant detrend per segment
    nper = int(Q["welch_win_s"] * FS)
    nper = min(nper, T)
    f, P = signal.welch(x, fs=FS, window="hann", nperseg=nper, noverlap=int(nper * Q["welch_overlap"]),
                        axis=0, detrend="constant")
    bp = {}
    for b, (lo, hi) in Q["bands"].items():
        m = (f >= lo) & (f < hi)
        bp[b] = np.trapz(P[m], f[m], axis=0)
    df = pd.DataFrame(dict(key=key, ch=names, ch_up=[n.upper() for n in names], mean=mean, sd=sd, rsd=rsd,
                           rms=rms, rms_sd=rms / np.maximum(sd, 1e-12), drift_per_min=slope, kurt=kurt,
                           frac_out5=frac_out, jump_max=jmax, jump_t_start_s=jmax_i / FS,
                           jump_t_end_s=(T - 1 - jmax_i) / FS, dx_rsd=d_rsd, edge_jump_start_rsd=edge_start,
                           edge_jump_end_rsd=edge_end, **{f"bp_{b}": v for b, v in bp.items()}))
    psd_med = np.median(P, axis=1)

    # 1-s alpha power on common57 after CAR (zero-phase; physiology descriptor, not a decoder input)
    mi = montage_idx(row, "common57")
    xa = x[:, mi]
    xa = xa - xa.mean(1, keepdims=True)
    xa = signal.sosfiltfilt(sos_bp(8.0, 13.0, 4, FS), xa, axis=0)
    nb = T // FS
    alpha = (xa[: nb * FS] ** 2).reshape(nb, FS, -1).mean(1).astype(np.float32)

    # hEOG proxy and true EOG, LP 1 Hz zero-phase, 4 Hz
    up = {n.upper(): i for i, n in enumerate(names)}
    L = [up[c] for c in HEOG_L if c in up]
    R = [up[c] for c in HEOG_R if c in up]
    lp = sos_lp(1.0, 4, FS)
    heog = signal.sosfiltfilt(lp, x[:, L].mean(1) - x[:, R].mean(1))[::32].astype(np.float32)
    try:
        lab = load_labels(key)
        eog = lab["eog"]
        eog = signal.sosfiltfilt(lp, eog.astype(float), axis=0)[::32].astype(np.float32) if eog.size else eog
        eog_desc = str(lab["eog_desc"])
    except FileNotFoundError:
        eog, eog_desc = np.zeros((0, 0), np.float32), ""
    np.savez_compressed(f2, f=f, psd_med=psd_med, alpha1s=alpha, alpha_ch=np.array(MONTAGES["common57"]),
                        heog=heog, heog_L=np.array([names[i] for i in L]), heog_R=np.array([names[i] for i in R]),
                        eog4=eog, eog_desc=eog_desc)
    df.to_parquet(f1)
    return key, "done"


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")]
    # UHD trials are large (253 ch): run them with fewer workers to bound RAM
    big = ti[ti.nch > 100]
    small = ti[ti.nch <= 100]
    log.info(f"QC on {len(ti)} trials ({len(big)} high-density)")
    r1 = Parallel(n_jobs=CFG["n_jobs"], verbose=0)(delayed(qc_trial)(r) for _, r in small.iterrows())
    r2 = Parallel(n_jobs=2, verbose=0)(delayed(qc_trial)(r) for _, r in big.iterrows())
    n_done = sum(s == "done" for _, s in r1 + r2)
    log.info(f"finished: {n_done} computed, {len(r1) + len(r2) - n_done} cached")
