"""R2 D0: label-free match-mismatch coupling diagnostic."""
from __future__ import annotations

import json
import os
import time
import zlib

# Published SW2 checkpoints use the glimpseonorm dominance feature. This must
# be set before common_exp is imported so load_trial resolves the right cache.
os.environ.setdefault("GLIMPSE_THR", "onorm")

import numpy as np
import torch
from scipy.stats import spearmanr

import clf_noise_aug_ft_lodo as B
import direct_classifier as DC
import eval_external as E
from common import DS_KEYS
from common_exp import EXP, FS, load_trial, rows_of
from decoders import DEV, _targets
from lagbank_sel import configure, external_targets, load_nets

RUN_ID = "r2_d0_mmdiag_20261107"
RUN_DIR = os.path.join(EXP, "experiments", "multi_agent_opt", "runs", RUN_ID)
OUT = os.path.join(EXP, "results", "research", "mm_diag.json")
MIN_SHIFT, MAX_SHIFT = 8 * FS, 30 * FS


def fold_nets(held: str) -> 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(B.pub_fold_ckpt(seed, held), map_location=DEV, weights_only=False)
        )
        net.eval()
        nets.append(net)
    return nets


def past_copy(stream: np.ndarray, delay: int) -> np.ndarray:
    out = np.zeros_like(stream)
    out[delay:] = stream[:-delay]
    return out


@torch.no_grad()
def mean_logits(nets, eeg: np.ndarray, stim: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    vals, starts = [], None
    for net in nets:
        d, starts = DC.logits(net, eeg, stim, step=4)
        vals.append(d)
    return np.mean(vals, axis=0), starts


def steady_mask(att: np.ndarray, indices: np.ndarray, min_s: float = 8.0) -> np.ndarray:
    att = np.asarray(att, dtype=int)
    age = np.zeros(len(att), np.int64)
    for i in range(1, len(att)):
        age[i] = age[i - 1] + 1 if att[i] == att[i - 1] else 0
    return age[np.clip(indices, 0, len(att) - 1)] >= int(min_s * FS)


def run_trials(dataset: str, trials: list[dict], subjects: list, nets) -> dict:
    per = {}
    started = time.time()
    for i, (tr, subject) in enumerate(zip(trials, subjects)):
        stim = tr["_S"]
        key_seed = zlib.crc32(str(tr["key"]).encode())
        rng = np.random.default_rng(key_seed)
        mm_parts = []
        valid_ref = None
        for stream_idx in (0, 1):
            delay = int(rng.integers(MIN_SHIFT, MAX_SHIFT + 1))
            mismatch = past_copy(stim[:, stream_idx], delay)
            pair = np.stack([stim[:, stream_idx], mismatch], axis=1)
            logit, starts = mean_logits(nets, tr["eeg"], pair)
            valid = starts >= delay
            mm_parts.append(logit[valid])
            valid_ref = valid
        att_logit, starts = mean_logits(nets, tr["eeg"], stim)
        lab_idx = np.maximum(starts - DC.HOP, 0)
        truth = tr["att"].astype(int)[lab_idx]
        stable = steady_mask(tr["att"], lab_idx)
        signed = att_logit * np.where(truth == 0, 1.0, -1.0)
        rec = per.setdefault(str(subject), {"mm": [], "attention": []})
        rec["mm"].extend(mm_parts)
        rec["attention"].append(signed[stable] if stable.any() else signed)
        if (i + 1) % 40 == 0 or i + 1 == len(trials):
            print(f"{dataset}: {i + 1}/{len(trials)} ({time.time() - started:.0f}s)", flush=True)
    rows = []
    for subject, rec in sorted(per.items()):
        mm = np.concatenate(rec["mm"])
        attention = np.concatenate(rec["attention"])
        rows.append({
            "subject": subject,
            "mm_acc": float(np.mean(mm > 0)),
            "mm_margin": float(np.mean(mm)),
            "steady_attention_acc": float(np.mean(attention > 0)),
            "n_mm": int(len(mm)),
        })
    mm_acc = np.array([r["mm_acc"] for r in rows])
    att_acc = np.array([r["steady_attention_acc"] for r in rows])
    corr = spearmanr(mm_acc, att_acc).statistic if len(rows) >= 3 else np.nan
    return {
        "dataset": dataset,
        "n_trials": len(trials),
        "n_subjects": len(rows),
        "mm_acc_subject_mean": float(mm_acc.mean()),
        "mm_acc_subject_median": float(np.median(mm_acc)),
        "mm_margin_subject_mean": float(np.mean([r["mm_margin"] for r in rows])),
        "steady_attention_acc_subject_mean": float(att_acc.mean()),
        "spearman_mm_vs_steady_attention": float(corr),
        "subjects": rows,
        "elapsed_s": time.time() - started,
    }


def lodo_dataset(ds: str) -> dict:
    trials, subjects = [], []
    for _, row in rows_of(ds).iterrows():
        tr = load_trial("eaP_n5_t60", row["key"])
        tr["_S"] = _targets(tr)
        trials.append(tr)
        subjects.append(row["subj_uid"])
    nets = fold_nets(ds)
    result = run_trials(ds, trials, subjects, nets)
    del nets
    torch.cuda.empty_cache()
    return result


def external_dataset(ds: str) -> dict:
    trials = E.ext_trials(ds)
    for tr in trials:
        tr["_S"] = external_targets(ds, tr)
    nets = load_nets()
    result = run_trials(ds, trials, [tr["subject"] for tr in trials], nets)
    del nets
    torch.cuda.empty_cache()
    return result


def main() -> None:
    configure()
    os.makedirs(RUN_DIR, exist_ok=True)
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    datasets = {ds: lodo_dataset(ds) for ds in DS_KEYS}
    datasets.update({ds: external_dataset(ds) for ds in ("AASD", "Carta2026")})
    in_domain = float(np.mean([datasets[ds]["mm_acc_subject_mean"] for ds in DS_KEYS]))
    deficit = in_domain - datasets["AASD"]["mm_acc_subject_mean"]
    route = "shift" if deficit >= 0.05 else "ceiling"
    payload = {
        "run_id": RUN_ID,
        "status": "complete",
        "method": "frozen SW2 f(E,s,s_past), both streams pooled; no attention labels in gate",
        "shift_samples": [MIN_SHIFT, MAX_SHIFT],
        "datasets": datasets,
        "decision": {
            "in_domain_mm_acc_mean": in_domain,
            "AASD_deficit": deficit,
            "threshold": 0.05,
            "route": route,
            "next": ["R2-1", "R2-2"] if route == "shift" else ["R2-3_PAD_diag"],
        },
    }
    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["decision"], indent=2), flush=True)


if __name__ == "__main__":
    main()
