"""Per-participant cardiovascular features from the pre-intervention stress task (plan/analysis-plan.md).

Phases (2 kHz; ECG, continuous blood pressure): baseline, Stroop, recovery.
Beats. ECG R peaks: 5-20 Hz band-pass; polarity chosen by the larger 99.9th-percentile
magnitude; peaks at least 0.33 s apart above 40% of the 99th percentile of the filtered signal.
Systolic peaks: blood pressure low-passed at 10 Hz; peaks at least 0.33 s apart with
prominence of at least 10 mmHg. A beat is an artefact if its RR interval is outside 0.3-2.0 s
(or systolic value outside 40-250 mmHg), or more than 25% (RR) / 20% (systolic) from the
9-beat running median.
Windows: baseline = 30 s to end; stress = the Stroop phase (which precedes recovery; PASAT
physiology is missing for most older adults, so it is not used); early recovery = 0-60 s;
late recovery = 120 s to end; recovery AR window = 30 s to end.
Features per signal (heart rate in bpm from RR; systolic pressure): mean per window;
lag-1 autocorrelation of the linearly detrended good-beat series (baseline and recovery AR
windows). A window is usable with at least 80% good beats and at least 100 good beats
(50 for early recovery).
Usage: python code/features.py <bids_dir> <sub> -> prints one JSON row
"""
import json
import sys

import numpy as np
import pandas as pd
from scipy.signal import butter, find_peaks, sosfiltfilt

FS = 2000.0
PHASES = ["baseline", "stroop", "recovery"]  # PASAT physiology is absent for most older adults


def load(bids, sub, phase):
    return pd.read_csv(f"{bids}/{sub}/ses-pre/beh/{sub}_ses-pre_task-stress_acq-{phase}_physio.tsv.gz", sep="\t")


def r_peaks(ecg):
    sos = butter(3, [5, 20], btype="band", fs=FS, output="sos")
    f = sosfiltfilt(sos, ecg)
    if abs(np.percentile(f, 0.1)) > abs(np.percentile(f, 99.9)):
        f = -f
    pk, _ = find_peaks(f, distance=int(0.33 * FS), height=0.4 * np.percentile(f, 99))
    return pk


def sys_peaks(bp):
    sos = butter(3, 10, btype="low", fs=FS, output="sos")
    f = sosfiltfilt(sos, bp)
    pk, _ = find_peaks(f, distance=int(0.33 * FS), prominence=10)
    return pk, f[pk]


def clean(values, lo, hi, tol):
    v = np.asarray(values, float)
    med = pd.Series(v).rolling(9, center=True, min_periods=3).median().to_numpy()
    good = (v >= lo) & (v <= hi) & (np.abs(v - med) <= tol * med)
    return good


def series(df):
    t = df["time"].to_numpy()
    rp = r_peaks(df["ecg"].to_numpy())
    rr_t, rr = t[rp][1:], np.diff(t[rp])
    rr_good = clean(rr, 0.3, 2.0, 0.25)
    sp, sv = sys_peaks(df["bp"].to_numpy())
    s_t = t[sp]
    s_good = clean(sv, 40, 250, 0.20)
    return {"hr": (rr_t, 60.0 / rr, rr_good), "sbp": (s_t, sv, s_good)}


def window(sig, a, b, min_good):
    t, v, g = sig
    m = (t >= a) & (t < b)
    n, ng = int(m.sum()), int((m & g).sum())
    ok = n > 0 and ng >= min_good and ng / n >= 0.8
    return v[m & g], t[m & g], ok, ng, n


def ar1(t, v):
    if len(v) < 20:
        return np.nan
    r = v - np.polyval(np.polyfit(t, v, 1), t)
    return float(np.corrcoef(r[:-1], r[1:])[0, 1])


def run(bids, sub):
    out = {"participant_id": sub}
    try:
        S = {p: series(load(bids, sub, p)) for p in PHASES}
        dur = {p: float(load(bids, sub, p)["time"].iloc[-1]) for p in ("baseline", "recovery")}
    except Exception as e:
        out["error"] = str(e)[:200]
        return out
    for sig in ("hr", "sbp"):
        vb, tb, okb, ngb, nb = window(S["baseline"][sig], 30, dur["baseline"] + 1, 100)
        vs = [window(S["stroop"][sig], 0, 1e9, 100)]
        ve, te, oke, _, _ = window(S["recovery"][sig], 0, 60, 50)
        vl, tl, okl, _, _ = window(S["recovery"][sig], 120, dur["recovery"] + 1, 100)
        va, ta, oka, nga, na = window(S["recovery"][sig], 30, dur["recovery"] + 1, 100)
        stress_ok = all(x[2] for x in vs)
        out[f"{sig}_ok"] = bool(okb and stress_ok and oke and okl and oka)
        out[f"{sig}_baseline"] = float(np.mean(vb)) if len(vb) else np.nan
        out[f"{sig}_stress"] = float(np.mean(np.concatenate([x[0] for x in vs]))) if stress_ok else np.nan
        out[f"{sig}_early_recovery"] = float(np.mean(ve)) if len(ve) else np.nan
        out[f"{sig}_late_recovery"] = float(np.mean(vl)) if len(vl) else np.nan
        out[f"{sig}_ar1_baseline"] = ar1(tb, vb)
        out[f"{sig}_ar1_recovery"] = ar1(ta, va)
        out[f"{sig}_good_share_baseline"] = round(ngb / nb, 4) if nb else 0.0
        out[f"{sig}_good_share_recovery"] = round(nga / na, 4) if na else 0.0
    return out


if __name__ == "__main__":
    print(json.dumps(run(sys.argv[1], sys.argv[2])))
