"""T3 CF-Null Step A diagnostic on frozen published SW2 classifiers."""
from __future__ import annotations

import json
import os
import pickle
import time

import numpy as np

import eval_external as E
from common_exp import EXP
from decoders import _targets
from lagbank_sel import configure, ensemble_logits, load_nets

RUN_ID = "t3_cfnull_diag_20261107"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
OUT = os.path.join(EXP, "results", "research", "cfnull_diag.json")
EVID = os.path.join(EXP, "results", "research")
SHIFT_S = 20
FS = 32


def cached_normal(ds: str) -> dict[str, np.ndarray]:
    seeds = []
    for seed in range(4):
        path = os.path.join(EVID, f"ext_clf_{ds}_w10b3sw2P_evidence_s{seed}.pkl")
        with open(path, "rb") as fh:
            seeds.append(pickle.load(fh))
    return {
        key: np.mean(
            [np.asarray(ev[key]["r0"]) - np.asarray(ev[key]["r1"]) for ev in seeds],
            axis=0,
        )
        for key in seeds[0]
    }


def ewma(x: np.ndarray, tau: float = 60.0) -> np.ndarray:
    alpha = 1.0 - np.exp(-1.0 / tau)
    out = np.empty_like(x, dtype=np.float64)
    state = 0.0
    norm = 0.0
    for i, value in enumerate(x):
        state = (1.0 - alpha) * state + alpha * float(value)
        norm = (1.0 - alpha) * norm + alpha
        out[i] = state / max(norm, 1e-12)
    return out


def diagnose(ds: str, nets) -> dict:
    normal = cached_normal(ds)
    by_subject = {}
    trials = E.ext_trials(ds)
    started = time.time()
    for i, tr in enumerate(trials):
        lag = SHIFT_S * FS
        null_eeg = np.zeros_like(tr["eeg"])
        null_eeg[lag:] = tr["eeg"][:-lag]
        d_null, starts = ensemble_logits(nets, null_eeg, _targets(tr), 0)
        d = np.asarray(normal[tr["key"]], np.float64)
        n = min(len(d), len(d_null), len(starts))
        d, d_null, starts = d[:n], d_null[:n], starts[:n]
        valid = starts >= lag
        truth = tr["att"].astype(int)[np.maximum(starts - 32, 0)]
        sign = np.where(truth == 0, 1.0, -1.0)
        subject = int(tr["subject"])
        rec = by_subject.setdefault(
            subject, {"d": [], "null": [], "signed_null": [], "label_sign": []}
        )
        rec["d"].append(d[valid])
        rec["null"].append(d_null[valid])
        rec["signed_null"].append((d_null * sign)[valid])
        rec["label_sign"].append(sign[valid])
        if (i + 1) % 40 == 0 or i + 1 == len(trials):
            print(f"{ds}: {i + 1}/{len(trials)} ({time.time() - started:.0f}s)", flush=True)

    subject_rows = []
    all_d, all_null = [], []
    for subject, rec in sorted(by_subject.items()):
        d = np.concatenate(rec["d"])
        dn = np.concatenate(rec["null"])
        signed = np.concatenate(rec["signed_null"])
        label_sign = np.concatenate(rec["label_sign"])
        all_d.append(d)
        all_null.append(dn)
        smooth = ewma(dn)
        corr = float(np.corrcoef(smooth, label_sign)[0, 1]) if np.std(smooth) > 0 else 0.0
        subject_rows.append({
            "subject": subject,
            "rho": float(np.std(dn) / max(np.std(d), 1e-12)),
            "null_acc1": float(np.mean(signed > 0)),
            "ewma_null_label_corr": corr,
        })
    d = np.concatenate(all_d)
    dn = np.concatenate(all_null)
    rho = float(np.std(dn) / max(np.std(d), 1e-12))
    return {
        "dataset": ds,
        "rho": rho,
        "rho_subject_median": float(np.median([r["rho"] for r in subject_rows])),
        "null_acc1_subject_mean": float(np.mean([r["null_acc1"] for r in subject_rows])),
        "ewma_null_label_corr_subject_mean": float(
            np.mean([r["ewma_null_label_corr"] for r in subject_rows])
        ),
        "gate_rho_ge_0p25": rho >= 0.25,
        "subjects": subject_rows,
        "elapsed_s": time.time() - started,
    }


def main() -> None:
    configure()
    os.makedirs(RUN_DIR, exist_ok=True)
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    nets = load_nets()
    datasets = {ds: diagnose(ds, nets) for ds in ("AASD", "Carta2026")}
    payload = {
        "run_id": RUN_ID,
        "shift_s": SHIFT_S,
        "seeds": [0, 1, 2, 3],
        "datasets": datasets,
        "proceed": any(row["gate_rho_ge_0p25"] for row in datasets.values()),
    }
    for path in (OUT, os.path.join(RUN_DIR, "metrics.json")):
        with open(path, "w") as fh:
            json.dump(payload, fh, indent=2)
    print(json.dumps(payload, indent=2), flush=True)


if __name__ == "__main__":
    main()
