"""Regen fold evidence for seeds 1-3 with correct switch schedule; finish scoring.

Models already trained under clf_hardswitch_ft_lodo.py. Only the LODO synthetic-switch
schedule was wrong for seeds≠0 (offset by 101*seed). External all5 evidence is unchanged.
"""
from __future__ import annotations

import os
import time

import numpy as np
import torch

import clf_hardswitch_ft_lodo as H
import direct_classifier as DC
from common import DS_KEYS, SEED
from common_exp import FS, fold_file, load_trial, rows_of, save_pickle
from decoders import DEV, _targets
from e1_switch import draw_switch_times
from run_experiment import log_to


def dump_fold_from_ckpt(seed, held, log):
    exp = H.exp_name(seed)
    ckpt = os.path.join(H.CKPT_ROOT, f"s{seed}", f"held-{held}.pt")
    net = DC.DirectNet(58, 3, "vlaai_ws").to(DEV)
    net.load_state_dict(torch.load(ckpt, map_location=DEV, weights_only=False))
    net.eval()
    srng = np.random.default_rng(SEED + DS_KEYS.index(held))
    ev, ctl = {}, {k: {} for k in ("normal", "zero_eeg", "shift_eeg", "no_frontal")}
    t0 = time.time()
    for _, r in rows_of(held).iterrows():
        tr = load_trial(H.PREP, r["key"])
        Sfeat, x, att, T128 = _targets(tr), tr["eeg"], tr["att"].astype(int), int(r["n"])
        times = draw_switch_times(srng, T128 / 128)
        srng.integers(0, 2)
        st128, cur, prev = np.zeros(T128, bool), False, 0
        for tt in times:
            s0 = min(T128 - 1, int(round(tt * 128)))
            st128[prev:s0] = cur
            cur, prev = not cur, s0
        st128[prev:] = cur
        st = st128[np.minimum(
            T128 - 1, np.round((np.arange(len(x)) / FS + tr["t0"]) * 128).astype(int))]
        Ssw = np.where(st[:, None, None], Sfeat[:, ::-1], Sfeat)
        lg, starts = DC.logits(net, x, Ssw)
        truth = (att ^ st)[np.maximum(starts - DC.HOP, 0)]
        n10 = len(lg) // 40
        ev[r["key"]] = dict(
            r0=lg / 2, r1=-lg / 2, att=truth.astype(np.int8),
            t_end=(starts / FS + tr["t0"]).astype(np.float32),
            r0_10=lg[:n10 * 40].reshape(n10, 40).mean(1) / 2,
            r1_10=-lg[:n10 * 40].reshape(n10, 40).mean(1) / 2,
            att10=(truth[:n10 * 40].reshape(n10, 40).mean(1) > 0.5).astype(np.int8),
            pre_switched=True)
        xf = x.copy()
        xf[:, DC.FRONTAL] = 0.0
        for name, xc in (("normal", x), ("zero_eeg", np.zeros_like(x)),
                         ("shift_eeg", np.roll(x, len(x) // 2, 0)), ("no_frontal", xf)):
            l1, s1 = DC.logits(net, xc, Sfeat, step=4)
            ctl[name].setdefault(r["subj_uid"], []).append(
                (l1 > 0) == (att[np.maximum(s1 - DC.HOP, 0)] == 0))
    controls = {
        k: dict(pooled=float(np.mean(np.concatenate([np.concatenate(v) for v in d.values()]))),
                subject_median=float(np.median([np.mean(np.concatenate(v)) for v in d.values()])))
        for k, d in ctl.items()}
    info = dict(
        decoder="direct_clf", prep=H.PREP, held_out=held, fit_s=0.0,
        total_s=time.time() - t0, lookahead_s=(DC.FUT + DC.HOP) / FS,
        best_val=None, channels=58, p_switch=H.P_SWITCH, clf_p_switch2=H.P_SWITCH2,
        ft_from="published_sw2", controls=controls, rescore_schedule_fix=True)
    path = fold_file(exp, held)
    save_pickle(dict(evidence={"causal": ev}, info=info), path)
    log(f"  regen seed{seed} {held} -> {path} ({info['total_s']:.0f}s) "
        + " ".join(f"{k} {v['pooled']:.3f}" for k, v in controls.items()))
    del net
    if DEV.type == "cuda":
        torch.cuda.empty_cache()


def main():
    log = log_to(H.LOG_PATH)
    log("=== RESCORE: regen folds seeds 1-3 with correct switch schedule ===")
    H.configure(0)
    H.mark_claim("running", "GPU rescore schedule fix s1-3; results_clf_hardswitch_ft.md")

    for seed in (1, 2, 3):
        for held in DS_KEYS:
            dump_fold_from_ckpt(seed, held, log)

    seed_payload = {}
    exps = []
    for seed in H.SEEDS:
        exp = H.exp_name(seed)
        exps.append(exp)
        per, mH, mA, ev = H.score_lodo_one(exp, log)
        ev_paths = {
            ds: os.path.join(H.EXT_DIR, f"ext_clf_{ds}{H.EXT_TAG}_evidence_s{seed}.pkl")
            for ds in ("AASD", "Carta2026")
        }
        ext, mu, sd = H.score_ext_one(ev, ev_paths, log, name=f"s{seed}")
        seed_payload[str(seed)] = dict(
            exp=exp, lodo=per, lodo_mean_H=mH, lodo_mean_Acc=mA,
            external=ext, emis_mu=mu, emis_sd=sd)

    payload = dict(
        method="clf-hardswitch-ft",
        p_switch=H.P_SWITCH, clf_p_switch2=H.P_SWITCH2, ft_lr=H.FT_LR,
        max_epochs=H.MAX_EPOCHS, steps_per_epoch=H.STEPS,
        seeds_list=H.SEEDS,
        seeds=seed_payload,
        schedule_fix="SEED+held only (rescored s1-3)",
    )

    log("--- equal-mean seed fuse ---")
    nd, _, evs = H.load_lodo_nd(exps, log)
    stream = H.mean_stream(nd)
    per, mH, mA = H.score_lodo_stream("mean_seeds", stream, evs[0], log)
    ext_nd, meta = H.load_ext_nd(len(H.SEEDS), log)
    ext_stream = {
        ds: {k: np.asarray(D, np.float64).mean(1) for k, D in table.items()}
        for ds, table in ext_nd.items()
    }
    A = np.concatenate([
        stream[ds][k] * np.where(evs[0][ds][k]["att"] == 0, 1.0, -1.0)
        for ds in DS_KEYS for k in stream[ds]
    ])
    mu, sd = float(A.mean()), float(A.std())
    ext = H.score_ext_stream("mean_seeds", ext_stream, meta, mu, sd, log)
    payload["mean_fuse"] = dict(
        lodo=per, lodo_mean_H=mH, lodo_mean_Acc=mA, external=ext,
        emis_mu=mu, emis_sd=sd)

    log("--- SW2-style fuse ---")
    try:
        clfs = [H.exp_name(s) for s in range(4)]
        per, mH, mA = H.fuse_sw2_lodo(clfs, log)
        clfs_fe = [[H.exp_name(s), H.EXT_TAG, s] for s in range(4)]
        ext = H.fuse_sw2_external(clfs_fe, log)
        payload["sw2_fuse"] = dict(lodo=per, lodo_mean_H=mH, lodo_mean_Acc=mA, external=ext)
    except Exception as e:
        log(f"  SW2 fuse skipped: {e!r}")
        payload["sw2_fuse_error"] = repr(e)

    rpath, head_name, head, carta, dacc, lodo_mH, lodo_mA = H.write_results(payload)
    note = (
        f"LODO {lodo_mH:.4f}/{lodo_mA:.2f} via {head_name}. "
        f"AASD {head['H']:.4f}/{head['Acc']:.2f} (Δ{dacc:+.2f} vs tip 53.53). "
        f"Carta {carta['H']:.4f}/{carta['Acc']:.2f}. Acc>60={'YES' if head['Acc'] > 60 else 'NO'}. "
        f"`{rpath}`."
    )
    H.mark_claim("done", note)
    H.append_already(note)
    H.update_status(
        f"AASD Acc {head['Acc']:.2f} (Δ{dacc:+.2f} vs tip). "
        f"Acc>60={'YES' if head['Acc'] > 60 else 'NO'}.")
    log(f"wrote {H.OUT_JSON} and {rpath}")
    log("=== done ===")
    print(
        f"\nRESULT AASD Acc={head['Acc']:.2f} vs tip 53.53 (Δ{dacc:+.2f}); "
        f"Acc>60={'YES' if head['Acc'] > 60 else 'NO'}; stream={head_name}",
        flush=True,
    )


if __name__ == "__main__":
    main()
