"""T1 LagBank-Sel Step A: frozen-SW2 stimulus-latency diagnostic.

External labels are read only to report lag curves. They never select a model
or hyperparameter. Positive lag delays the stimulus; negative lag delays EEG.
Both operations are causal left shifts with zero prefix.
"""
from __future__ import annotations

import argparse
import csv
import json
import os
import time

# Published SW2 classifiers were trained with the `glimpseonorm` dominance
# feature. Set this before importing common_exp/eval_external, which resolve
# the external glimpse directory at import time.
os.environ.setdefault("GLIMPSE_THR", "onorm")

import numpy as np
import torch

import decoders
import direct_classifier as DC
import eval_external as E
from common_exp import CFG, DATA_EXP, EXP, EXTERNAL_DATA, FS
from decoders import D, DEV, _targets

LAGS = tuple(range(-16, 17))
RUN_ID = "t1_latency_20261106"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
OUT_JSON = os.path.join(EXP, "results", "research", "lagbank_diag.json")
OUT_CSV = os.path.join(EXP, "results", "research", "lagbank_diag.csv")


def configure() -> None:
    DC.W = int(10 * FS)
    DC.POS0, DC.LAB = DC.W - DC.FUT - DC.HOP, DC.W - FS
    D["targets"] = ["env", "onset", "dom"]
    D["model_blocks"] = 3
    decoders.apply_overrides(["model_blocks=3"], [])


def checkpoint(seed: int) -> str:
    path = os.path.join(DATA_EXP, "models", f"all5_direct_clf_w10b3sw2P_s{seed}.pt")
    if not os.path.exists(path):
        raise FileNotFoundError(path)
    return path


def load_nets() -> list[torch.nn.Module]:
    nets = []
    for seed in range(4):
        net = DC.DirectNet(58, 3, "vlaai_ws").to(DEV)
        net.load_state_dict(torch.load(checkpoint(seed), map_location=DEV, weights_only=False))
        net.eval()
        nets.append(net)
    return nets


def shifted_pair(eeg: np.ndarray, stim: np.ndarray, lag: int) -> tuple[np.ndarray, np.ndarray]:
    if lag > 0:
        out = np.zeros_like(stim)
        out[lag:] = stim[:-lag]
        return eeg, out
    if lag < 0:
        k = -lag
        out = np.zeros_like(eeg)
        out[k:] = eeg[:-k]
        return out, stim
    return eeg, stim


def external_targets(ds: str, tr: dict) -> np.ndarray:
    """Build the exact env/onset/dom input used by published SW2 checkpoints."""
    if "dom" not in tr:
        path = os.path.join(
            EXTERNAL_DATA, ds, "cache", "glimpseonorm", f"{tr['key']}.npz"
        )
        if not os.path.exists(path):
            raise KeyError(
                f"{ds}/{tr['key']} has no 'dom' and published glimpseonorm "
                f"cache is missing: {path}"
            )
        with np.load(path) as z:
            if "dom" not in z.files:
                raise KeyError(f"'dom' missing from {path}; keys={z.files}")
            tr = {**tr, "dom": z["dom"]}
    return _targets(tr)


@torch.no_grad()
def ensemble_logits(
    nets: list[torch.nn.Module], eeg: np.ndarray, stim: np.ndarray, lag: int
) -> tuple[np.ndarray, np.ndarray]:
    x, s = shifted_pair(eeg, stim, lag)
    logits = []
    starts = None
    for net in nets:
        lg, st = DC.logits(net, x, s, step=4)
        logits.append(lg)
        starts = st
    return np.mean(logits, axis=0), starts


def bootstrap_se(delta: np.ndarray, seed: int, n_boot: int = 4000) -> float:
    delta = np.asarray(delta, dtype=float)
    if len(delta) < 2:
        return float("nan")
    rng = np.random.default_rng(seed)
    means = np.empty(n_boot)
    for i in range(n_boot):
        means[i] = rng.choice(delta, len(delta), replace=True).mean()
    return float(means.std(ddof=1))


def diagnose_dataset(ds: str, nets: list[torch.nn.Module], max_trials: int = 0) -> dict:
    trials = E.ext_trials(ds)
    if max_trials:
        trials = trials[:max_trials]
    by_lag: dict[int, dict[int, list[np.ndarray]]] = {
        lag: {} for lag in LAGS
    }
    signed_by_lag: dict[int, dict[int, list[np.ndarray]]] = {
        lag: {} for lag in LAGS
    }
    started = time.time()
    for ti, tr in enumerate(trials):
        stim = external_targets(ds, tr)
        subject = int(tr["subject"])
        for lag in LAGS:
            lg, starts = ensemble_logits(nets, tr["eeg"], stim, lag)
            truth = tr["att"].astype(int)[np.maximum(starts - DC.HOP, 0)]
            signed = lg * np.where(truth == 0, 1.0, -1.0)
            by_lag[lag].setdefault(subject, []).append((signed > 0).astype(np.float32))
            signed_by_lag[lag].setdefault(subject, []).append(signed.astype(np.float32))
        if (ti + 1) % 20 == 0 or ti + 1 == len(trials):
            print(f"{ds}: {ti + 1}/{len(trials)} trials ({time.time() - started:.0f}s)", flush=True)

    subj_acc = {
        lag: {
            s: float(np.concatenate(parts).mean())
            for s, parts in subjects.items()
        }
        for lag, subjects in by_lag.items()
    }
    subj_signed = {
        lag: {
            s: float(np.concatenate(parts).mean())
            for s, parts in subjects.items()
        }
        for lag, subjects in signed_by_lag.items()
    }
    subjects = sorted(subj_acc[0])
    rows = []
    for lag in LAGS:
        acc = np.array([subj_acc[lag][s] for s in subjects])
        signed = np.array([subj_signed[lag][s] for s in subjects])
        delta = acc - np.array([subj_acc[0][s] for s in subjects])
        rows.append(
            dict(
                dataset=ds,
                lag_samples=lag,
                lag_ms=1000.0 * lag / FS,
                n_subjects=len(subjects),
                n_trials=len(trials),
                acc1=float(acc.mean()),
                acc1_subject_median=float(np.median(acc)),
                mean_signed=float(signed.mean()),
                delta_acc1_vs_zero=float(delta.mean()),
                delta_subject_bootstrap_se=bootstrap_se(delta, 31000 + lag),
            )
        )
    peak = dict(max(rows, key=lambda r: r["acc1"]))
    se = peak["delta_subject_bootstrap_se"]
    peak["over_2se"] = bool(
        peak["lag_samples"] != 0
        and np.isfinite(se)
        and peak["delta_acc1_vs_zero"] > 2 * se
    )
    return {
        "dataset": ds,
        "rows": rows,
        "peak": peak,
        "zero": next(r for r in rows if r["lag_samples"] == 0),
        "elapsed_s": time.time() - started,
    }


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--datasets", default="AASD")
    ap.add_argument("--max-trials", type=int, default=0)
    args = ap.parse_args()
    configure()
    os.makedirs(RUN_DIR, exist_ok=True)
    os.makedirs(os.path.dirname(OUT_JSON), exist_ok=True)
    nets = load_nets()
    results = [
        diagnose_dataset(ds, nets, args.max_trials)
        for ds in args.datasets.split(",") if ds
    ]
    rows = [row for result in results for row in result["rows"]]
    with open(OUT_CSV, "w", newline="") as fh:
        writer = csv.DictWriter(fh, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)
    payload = {
        "run_id": RUN_ID,
        "mode": "diag",
        "lags_samples": list(LAGS),
        "fs": FS,
        "seeds": [0, 1, 2, 3],
        "external_labels_use": "diagnostic_only",
        "datasets": {r["dataset"]: r for r in results},
    }
    with open(OUT_JSON, "w") as fh:
        json.dump(payload, fh, indent=2)
    with open(os.path.join(RUN_DIR, "metrics.json"), "w") as fh:
        json.dump(payload, fh, indent=2)
    print(json.dumps({r["dataset"]: r["peak"] for r in results}, indent=2), flush=True)


if __name__ == "__main__":
    main()
