"""Builds cache/F6.npy, F7.npy, F8.npy and SG.npy (+ *_names.npy), rows in the order of R.extract()'s `win`; E4 filtering as everywhere."""
import os
import sys
import time
from multiprocessing import Pool

import mne
import numpy as np

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(os.path.dirname(HERE))
sys.path.insert(0, HERE)
for p in ("experiments/stft_tree", "experiments/iir_filter"):
    sys.path.insert(0, os.path.join(ROOT, p))
import ffeat2 as G  # noqa: E402
import run_iir_filter as I  # noqa: E402
import run_stft_tree as R  # noqa: E402

mne.set_log_level("ERROR")
_, _, WIN_DF, REC = R.extract()
COUNTS = WIN_DF.groupby("rec").size()
SOS = I.design(None)


def work(i):
    r = REC.loc[i]
    n = int(COUNTS[i])
    x = mne.io.read_raw_brainvision(f"{R.BIDS}/{r.subject}/{r.session_id}/eeg/{r.rec_id}_task-sleeponset_eeg.vhdr", preload=True,
                                    verbose="ERROR").get_data(picks=R.CH) * 1e6
    x = x[:, : n * G.WIN].copy()
    x[:, :128] = 0.0
    xf, _ = I.filter_stream(SOS, x)
    return (i,) + G.all_blocks(xf.reshape(4, n, G.WIN).transpose(1, 0, 2))


if __name__ == "__main__":
    t0 = time.time()
    order = list(REC.index)
    res = {}
    with Pool(6) as pool:
        for k, out in enumerate(pool.imap_unordered(work, order)):
            res[out[0]] = out[1:]
            if (k + 1) % 90 == 0:
                print(f"{k + 1}/{len(order)} recordings, {time.time() - t0:.0f} s", flush=True)
    for j, (name, names) in enumerate((("F6", G.NAMES_F6), ("F7", G.NAMES_F7), ("F8", G.NAMES_F8), ("SG", G.NAMES_SG))):
        A = np.concatenate([res[i][j] for i in order])
        assert A.shape == (len(WIN_DF), len(names)) and np.isfinite(A).all(), (name, A.shape)
        np.save(os.path.join(HERE, "cache", f"{name}.npy"), A)
        np.save(os.path.join(HERE, "cache", f"{name}_names.npy"), np.array(names))
        print(f"{name}: {A.shape} saved", flush=True)
    print(f"done in {time.time() - t0:.0f} s")
