"""Event-lock real AASD/Carta switches on base and EA-preprocessed EEG caches.

The `mat` cache is the available base/pre-EA input, not unfiltered acquisition EEG.
The script compares it with `eaP_n5_t60`; all reported EEG amplitudes are in
per-trial z units. External annotations are used to align descriptive plots only.
"""
from __future__ import annotations

import os

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from common_exp import EXTERNAL_DATA, EXP
from common import DS_KEYS as CORPUS_KEYS, load_labels, trial_index as corpus_trial_index

DATASETS = ("AASD", "Carta2026")
PREPS = ("mat", "eaP_n5_t60")
FS = 32
WINDOW_S = 1.0
HOP_S = 0.25
EVENT_RADIUS_S = 6.0
OUT_DIR = os.path.join(EXP, "results", "research")


def load_trials(dataset: str, prep: str):
    cache = os.path.join(EXTERNAL_DATA, dataset, "cache")
    index = pd.read_csv(os.path.join(cache, "index.csv"))
    trials = []
    for row in index.itertuples(index=False):
        path = os.path.join(cache, prep, f"{row.key}.npz")
        with np.load(path) as data:
            eeg = np.asarray(data["eeg"], dtype=np.float64)
            env = np.asarray(data["env"], dtype=np.float64)
            att = np.asarray(data["att"], dtype=np.int8)
            t0 = float(data["t0"])
        n = min(len(eeg), len(env), len(att))
        trials.append(dict(
            key=row.key, subject=int(row.subject), trial=int(row.trial),
            eeg=eeg[:n], env=env[:n], att=att[:n], t0=t0,
            channels=int(np.count_nonzero(np.std(eeg, axis=0) > 0)),
        ))
    return index, trials


def window_features(eeg, env, att, start):
    stop = start + int(round(WINDOW_S * FS))
    x = eeg[start:stop]
    e = env[start:stop]
    y = att[start:stop]
    if len(x) != int(round(WINDOW_S * FS)) or len(e) != len(x):
        return None

    x = x - x.mean(axis=0, keepdims=True)
    e = e - e.mean(axis=0, keepdims=True)
    x_energy = np.sum(x * x, axis=0)
    e_energy = np.sum(e * e, axis=0)
    corr = (x.T @ e) / np.sqrt(np.maximum(x_energy[:, None] * e_energy[None, :], 1e-12))
    speaker_strength = np.mean(np.abs(corr), axis=0)
    attended = int(np.mean(y) >= 0.5)
    unattended = 1 - attended

    freqs = np.fft.rfftfreq(len(x), d=1.0 / FS)
    power = np.abs(np.fft.rfft(x, axis=0)) ** 2 / len(x)
    band_power = {}
    for name, lo, hi in (("delta", 1.0, 4.0), ("theta", 4.0, 8.0), ("alpha", 8.0, 9.0)):
        mask = (freqs >= lo) & (freqs < hi)
        band_power[name] = float(power[mask].mean()) if mask.any() else float("nan")
    return dict(
        rms_z=float(np.sqrt(np.mean(x * x))),
        attended_corr_abs=float(speaker_strength[attended]),
        unattended_corr_abs=float(speaker_strength[unattended]),
        tracking_margin=float(speaker_strength[attended] - speaker_strength[unattended]),
        **{f"{name}_power": value for name, value in band_power.items()},
    )


def analyze_trial(dataset, prep, trial):
    fs = FS
    radius = int(round(EVENT_RADIUS_S / HOP_S))
    offsets = np.arange(-radius, radius + 1) * int(round(HOP_S * fs))
    changes = np.flatnonzero(trial["att"][1:] != trial["att"][:-1]) + 1
    rows = []
    half_window = int(round(WINDOW_S * fs / 2))
    for event_id, event_idx in enumerate(changes):
        before, after = int(trial["att"][event_idx - 1]), int(trial["att"][event_idx])
        event_time = trial["t0"] + event_idx / fs
        for offset in offsets:
            center = int(event_idx + offset)
            start = center - half_window
            features = window_features(trial["eeg"], trial["env"], trial["att"], start)
            if features is None:
                continue
            rows.append(dict(
                dataset=dataset, prep=prep, subject=trial["subject"], trial=trial["trial"],
                key=trial["key"], event_id=event_id, from_stream=before, to_stream=after,
                event_time_s=event_time, lag_s=float(offset / fs), channels=trial["channels"],
                **features,
            ))
    return changes, rows


def summarize_subject_changes(events):
    rows = []
    for (dataset, prep, subject), group in events.groupby(["dataset", "prep", "subject"]):
        pre = group.loc[group.lag_s.between(-4.0, -1.0), "tracking_margin"].mean()
        post = group.loc[group.lag_s.between(1.0, 4.0), "tracking_margin"].mean()
        rows.append(dict(dataset=dataset, prep=prep, subject=subject,
                         pre_tracking_margin=pre, post_tracking_margin=post,
                         delta_post_minus_pre=post - pre))
    return pd.DataFrame(rows)


def bootstrap_mean_ci(values, seed=0, n_boot=2000):
    values = np.asarray(values, dtype=np.float64)
    values = values[np.isfinite(values)]
    if not len(values):
        return float("nan"), float("nan"), float("nan")
    rng = np.random.default_rng(seed)
    indices = rng.integers(0, len(values), size=(n_boot, len(values)))
    means = values[indices].mean(axis=1)
    return float(values.mean()), float(np.quantile(means, 0.025)), float(np.quantile(means, 0.975))


def corpus_profiles():
    index = corpus_trial_index()
    rows = []
    for dataset in CORPUS_KEYS:
        group = index[index.ds == dataset]
        event_count = 0
        for key in group.key:
            azimuth = np.asarray(load_labels(key)["att_az"], dtype=np.float64).reshape(-1)
            direction = np.sign(azimuth)
            event_count += int(np.count_nonzero(direction[1:] != direction[:-1]))
        rows.append(dict(
            dataset=dataset, prep="source_metadata", subjects=int(group.subject.nunique()),
            trials=len(group), source_fs_hz=int(group.fs.mode().iloc[0]), cache_fs_hz=FS,
            duration_median_s=float(group.dur_s.median()),
            source_channels_min=int(group.nch.min()), source_channels_max=int(group.nch.max()),
            genuine_direction_label_changes=event_count,
            lodo_switch_evaluation="synthetic switches; genuine direction event only for AVGC",
        ))
    return rows


def analyze_posterior_events():
    import json

    import causal_ds_temp as CD
    import ensemble_clf_nested as N
    import ensemble_clf_transformer_v4 as V4
    import stem_ms96_irm_synth_fuse as SF

    N.load_all()
    result_path = os.path.join(OUT_DIR, "causal_ds_temp.json")
    with open(result_path) as handle:
        result = json.load(handle)
    tau_s = float(result["external_selection"]["tau_s"])
    corpus = CD.load_pkl(os.path.join(
        EXP, "models", "focal_synth_adapt_readout", "cache",
        "focal_synth_w05__all5_corpus.pkl"))
    external = CD.load_pkl(os.path.join(
        EXP, "models", "focal_synth_adapt_readout", "cache",
        "focal_synth_w05__all5_external.pkl"))
    _logits, metadata = SF.load_external()
    mu, sd = SF.emissions_from(corpus, N.G["att"], datasets=list(V4.CORPUS))
    event_rows, summary_rows = [], []
    offsets_s = np.arange(-8.0, 20.0001, HOP_S)

    for dataset in DATASETS:
        for key, evidence in external[dataset].items():
            item = metadata[dataset][key]
            posterior = CD.forward_posterior(evidence, mu, sd * CD.SCALE, CD.P_STAY)
            posterior = CD.smooth_posterior(posterior, tau_s)
            decisions = posterior > 0.5
            decision_times = np.asarray(item["t_end"], dtype=np.float64) + 0.75 - 1.0
            labels = np.asarray(item["att128"], dtype=np.int8)
            changes = np.flatnonzero(labels[1:] != labels[:-1]) + 1
            for event_id, sample in enumerate(changes):
                event_time = sample / 128.0
                target = int(labels[sample])
                target_probability = posterior if target == 1 else 1.0 - posterior
                relative_times = decision_times - event_time
                sampled = []
                for offset in offsets_s:
                    idx = int(np.argmin(np.abs(relative_times - offset)))
                    if abs(relative_times[idx] - offset) > HOP_S / 2 + 1e-8:
                        continue
                    probability = float(target_probability[idx])
                    event_rows.append(dict(
                        dataset=dataset, subject=int(item["subject"]), trial=key,
                        event_id=event_id, from_state=int(labels[sample - 1]),
                        to_state=target, event_time_s=event_time,
                        lag_s=float(offset), p_target=probability,
                        hard_decision=int(decisions[idx]), tau_s=tau_s,
                    ))
                    sampled.append((relative_times[idx], probability))
                after = [(t, p) for t, p in sampled if t >= 0.0]
                cross20 = next((t for t, p in after if p >= 0.2), np.nan)
                cross80 = next((t for t, p in after if p >= 0.8), np.nan)
                summary_rows.append(dict(
                    dataset=dataset, subject=int(item["subject"]), trial=key,
                    event_id=event_id, from_state=int(labels[sample - 1]), to_state=target,
                    tau_s=tau_s, target_p_at_switch=float(target_probability[
                        int(np.argmin(np.abs(relative_times)))
                    ]),
                    target_p_20_time_s=float(cross20), target_p_80_time_s=float(cross80),
                    posterior_rise_20_80_s=float(cross80 - cross20)
                    if np.isfinite(cross20) and np.isfinite(cross80) else float("nan"),
                ))

    curves = pd.DataFrame(event_rows)
    summary = pd.DataFrame(summary_rows)
    curves.to_csv(os.path.join(OUT_DIR, "attention_transition_posterior_event_locked.csv"), index=False)
    summary.to_csv(os.path.join(OUT_DIR, "attention_transition_posterior_event_summary.csv"), index=False)
    return curves, summary


def main():
    os.makedirs(OUT_DIR, exist_ok=True)
    event_rows, profiles = [], []
    for dataset in DATASETS:
        for prep in PREPS:
            index, trials = load_trials(dataset, prep)
            event_count = 0
            for trial in trials:
                changes, rows = analyze_trial(dataset, prep, trial)
                event_count += len(changes)
                event_rows.extend(rows)
            profiles.append(dict(
                dataset=dataset, prep=prep, subjects=int(index.subject.nunique()),
                trials=len(index), source_fs_hz=128 if dataset == "AASD" else 64,
                cache_fs_hz=FS, mean_switches_per_trial=float(index.n_switches.mean()),
                median_switches_per_trial=float(index.n_switches.median()),
                channels_min=min(trial["channels"] for trial in trials),
                channels_max=max(trial["channels"] for trial in trials),
                aligned_switches=event_count,
                source_description=(
                    "128 Hz processed MAT before 1-9 Hz/downsample/CAR/z-score/EA; "
                    "original CNT not decoded by this script"
                    if dataset == "AASD" else
                    "64 Hz ICA-cleaned CND (0.5-20 Hz) before 1-9 Hz/downsample/CAR/z-score/EA"
                ),
            ))

    events = pd.DataFrame(event_rows)
    profiles.extend(corpus_profiles())
    profile = pd.DataFrame(profiles)
    subject_changes = summarize_subject_changes(events)
    profile.to_csv(os.path.join(OUT_DIR, "attention_transition_dataset_profile.csv"), index=False)
    events.to_csv(os.path.join(OUT_DIR, "attention_transition_event_locked.csv"), index=False)
    subject_changes.to_csv(os.path.join(OUT_DIR, "attention_transition_subject_summary.csv"), index=False)

    summary_rows = []
    for (dataset, prep), group in subject_changes.groupby(["dataset", "prep"]):
        mean, low, high = bootstrap_mean_ci(group.delta_post_minus_pre)
        summary_rows.append(dict(
            dataset=dataset, prep=prep, subjects=len(group),
            mean_pre_tracking=float(group.pre_tracking_margin.mean()),
            mean_post_tracking=float(group.post_tracking_margin.mean()),
            mean_delta_post_minus_pre=mean, ci95_low=low, ci95_high=high,
        ))
    summary = pd.DataFrame(summary_rows)
    summary.to_csv(os.path.join(OUT_DIR, "attention_transition_summary.csv"), index=False)
    posterior_events, posterior_summary = analyze_posterior_events()

    fig, axes = plt.subplots(2, 1, figsize=(9, 8), sharex=True)
    for (dataset, prep), group in events.groupby(["dataset", "prep"]):
        color = "#176B87" if dataset == "AASD" else "#C45137"
        linestyle = "-" if prep == "mat" else "--"
        curve = group.groupby("lag_s")["tracking_margin"].mean()
        axes[0].plot(curve.index, curve.values, color=color, linestyle=linestyle,
                     label=f"{dataset} / {prep}")
        rms = group.groupby("lag_s")["rms_z"].mean()
        axes[1].plot(rms.index, rms.values, color=color, linestyle=linestyle,
                     label=f"{dataset} / {prep}")
    for ax in axes:
        ax.axvline(0.0, color="#333333", linewidth=0.8)
        ax.axhline(0.0, color="#888888", linewidth=0.6)
        ax.grid(alpha=0.2)
        ax.legend(frameon=False, ncol=2)
    axes[0].set_ylabel("abs-corr(attended) - abs-corr(unattended)")
    axes[1].set_ylabel("EEG RMS (per-trial z units)")
    axes[1].set_xlabel("Time from annotated attention switch (s)")
    fig.suptitle("Real-switch event-lock: base mat vs causal EA")
    fig.tight_layout()
    fig.savefig(os.path.join(OUT_DIR, "attention_transition_event_locked.png"), dpi=160)
    plt.close(fig)
    fig, ax = plt.subplots(figsize=(9, 4.5))
    for dataset, group in posterior_events.groupby("dataset"):
        color = "#176B87" if dataset == "AASD" else "#C45137"
        curve = group.groupby("lag_s")["p_target"].mean()
        ax.plot(curve.index, curve.values, color=color, label=dataset)
    ax.axvline(0.0, color="#333333", linewidth=0.8)
    ax.axhline(0.5, color="#888888", linewidth=0.6)
    ax.set(xlabel="Time from real annotated switch (s)", ylabel="P(new attended stream)",
           title="Causal HMM posterior around AASD/Carta switches")
    ax.grid(alpha=0.2)
    ax.legend(frameon=False)
    fig.tight_layout()
    fig.savefig(os.path.join(OUT_DIR, "attention_transition_posterior_event_locked.png"), dpi=160)
    plt.close(fig)
    print(summary.to_string(index=False), flush=True)
    print("Posterior event rise 20→80%:")
    print(posterior_summary.groupby("dataset").posterior_rise_20_80_s.agg(["count", "median", "mean"]).to_string())


if __name__ == "__main__":
    main()