"""Export compact, spreadsheet-friendly raw EEG trial excerpts for inspection.

Each CSV retains the complete stored 128 Hz trial, all EEG channels, and every
envelope feature/stream.
"""
from __future__ import annotations

import csv
import pickle
from pathlib import Path

import numpy as np


DATA_ROOT = Path("/root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset")
RAW = DATA_ROOT / "data/superhuge/raw"
OUT = DATA_ROOT / "reports/eda_raw/trial_csv_examples"


def trial_stem(meta: dict) -> str:
    return (
        f"dataset-{meta['dataset_id']:03d}-subject-{meta['subject_id']:03d}"
        f"-trial-{meta['trial_id']:03d}"
    )


def channel_names(meta: dict) -> list[str]:
    info = meta["channel_infos"]
    return [str(info[index]["name"]) for index in sorted(info)]


def main() -> None:
    OUT.mkdir(parents=True, exist_ok=True)
    with (RAW / "meta/metadata.pkl").open("rb") as handle:
        metadata: dict[str, dict] = pickle.load(handle)

    # One deterministic, earliest subject/trial example from every source dataset.
    selected: dict[int, dict] = {}
    for meta in metadata.values():
        dataset_id = int(meta["dataset_id"])
        if dataset_id not in selected or (meta["subject_id"], meta["trial_id"]) < (
            selected[dataset_id]["subject_id"], selected[dataset_id]["trial_id"]
        ):
            selected[dataset_id] = meta

    manifest_rows: list[dict[str, object]] = []
    for dataset_id, meta in sorted(selected.items()):
        stem = trial_stem(meta)
        eeg = np.load(RAW / "eeg" / f"{stem}.npy", mmap_mode="r")
        env = np.load(RAW / "stimuli/env" / f"{stem}_env.npy", mmap_mode="r")
        fs = float(meta["fs"])
        length = len(eeg)
        names = channel_names(meta)
        if len(names) != eeg.shape[1]:
            raise ValueError(f"Channel-name count mismatch for {stem}")

        env_cols = [
            f"env_feature_{feature + 1}_stream_{stream + 1}"
            for feature in range(env.shape[1])
            for stream in range(env.shape[2])
        ]
        output_name = f"{stem}_full_raw.csv"
        output_path = OUT / output_name
        columns = ["sample_index", "time_s", *[f"eeg_{name}" for name in names], *env_cols]
        with output_path.open("w", newline="") as handle:
            writer = csv.writer(handle)
            writer.writerow(columns)
            for i in range(length):
                writer.writerow(
                    [i, f"{i / fs:.8f}", *eeg[i].tolist(), *env[i].reshape(-1).tolist()]
                )

        manifest_rows.append(
            {
                "dataset_id": dataset_id,
                "dataset_name": meta["dataset_name"],
                "subject_id": meta["subject_id"],
                "trial_id": meta["trial_id"],
                "trial_label": meta.get("label", ""),
                "sampling_rate_hz": fs,
                "source_trial_duration_s": len(eeg) / fs,
                "excerpt_duration_s": length / fs,
                "eeg_channels": eeg.shape[1],
                "envelope_features": env.shape[1],
                "envelope_streams": env.shape[2],
                "csv_file": output_name,
            }
        )

    with (OUT / "manifest.csv").open("w", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(manifest_rows[0]))
        writer.writeheader()
        writer.writerows(manifest_rows)

    (OUT / "README.md").write_text(
        "# Raw trial CSV examples\n\n"
        "Each CSV is one complete deterministic representative trial per dataset, at "
        "the original stored 128 Hz. Columns are `sample_index`, `time_s`, "
        "then all raw EEG channels (`eeg_*`) and envelope feature/stream columns "
        "(`env_feature_*_stream_*`). See `manifest.csv` for the source trial and its "
        "metadata. These are excerpts for visual inspection, not resampled or preprocessed data.\n"
    )
    print(f"Wrote {len(manifest_rows)} examples to {OUT}")


if __name__ == "__main__":
    main()
