"""4+4+4+4 (+ stem_ms96 of eeg-thao.zip as a fifth member): LODO and real-set scores (user, 2026-11-11).

Members, as st_ensemble.py (classic LODO calibration: emissions and scales from the other four datasets):
  dec   4 reference 3-target decoders (LDA over env/onset/dom per seed)     clf  4 DirectNet sw2
  tr    rate-aux stage-2 Transformer of the outer fold (tb_members)        bm   BMMS3, mean of 4 seeds
  stem  stem_ms96: the 24 causal 'ms' features of the FULL 4-seed DirectNet logit sequence of a trial through the fold
        model trained WITHOUT the outer dataset (stem_ms96__held-<outer>; on the outer dataset this is a true LODO
        prediction; on the four calibration datasets the model saw the data, so only its scale and the HMM emissions
        come from in-sample streams - the same caveat as BMMS3). Real sets (outer ALL): mean of the five fold models.
        Variant orig = f(x), sym = (f(x) - f(-x)) / 2 (column-swap symmetric). Checkpoints: weights_only, numpy only.
tr, bm, stem are standardised by their signed std on the calibration datasets, dec / clf as nested_stack_fusion.
Combinations fixed in advance; HMM p_stay 0.998 and 0.95; scorer kappa_next_inclusive (provisional).
Output results/research/stem_ensemble.csv, stem_ensemble_summary.txt.
"""
import os
import numpy as np
import pandas as pd
import torch

import eval_external as E
import e1_switch
import nested_schedule_eval as N
import nested_stack_fusion as F
import r1_acc_decision_grid as R
import score as S
import tb_members as TB
from common import DS_KEYS
from common_exp import EXP
from eval_stem_external import LogitTransformer, ms_features, streams_of
from stem_kappa import allow_numpy
from sub_fuse import bvec

RES = os.path.join(EXP, 'results', 'research')
OUT = os.path.join(RES, 'stem_ensemble.csv')
CKPT = os.path.join(EXP, '..', '..', 'eeg-thao_unzipped', 'eeg-thao', 'models', 'stem_ms96_image_split')
SEEDS = (0, 1, 2, 3)
sfx = lambda i: '' if i == 0 else f'_s{i}'
CLF = [f'direct_clf__eaP_n5_t60_w10b3_ptSPK{sfx(i)}_aug-sw2' for i in SEEDS]
DEC = [f'vlaai_ws__eaP_n5_t60_aug_cluster_onset_dom_xFUG_ptSPK{sfx(i)}' for i in SEEDS]
BM = [f'direct_clf__eaP_n5_t60_w10_bmms3enh_ptSPK_s{i}' for i in SEEDS]
NC, ND = 4, 4
X16 = dict(clf_cols=range(NC), dec_cols=[NC + 3 * i for i in range(ND)])
B = {'dec': .3375, 'clf': .3375, 'tr': .225, 'bm': .1}                     # ref_t_bm = the 4+4+4+4
scaled = lambda w, extra: {**{m: c * (1 - sum(extra.values())) for m, c in w.items()}, **extra}
COMBOS = {'ref_t_bm': B,
          'ref_bm': {'dec': 1 / 3, 'clf': 1 / 3, 'bm': 1 / 3},
          'stem': {'stem': 1.}, 'stem_sym': {'ssym': 1.},
          'ref_t_bm_stem10': scaled(B, {'stem': .1}),
          'ref_t_bm_stem20': scaled(B, {'stem': .2}),
          'ref_t_bm_stem50': scaled(B, {'stem': .5}),
          'eq5': {m: .2 for m in ('dec', 'clf', 'tr', 'bm', 'stem')},
          'ref_t_bm_sym20': scaled(B, {'ssym': .2}),
          'eq5_sym': {m: .2 for m in ('dec', 'clf', 'tr', 'bm', 'ssym')}}
P_GRID = (0.998, 0.95)


def stem_models(dev):
    allow_numpy(CKPT)
    out = {}
    for held in DS_KEYS:
        ck = torch.load(os.path.join(CKPT, f'stem_ms96__held-{held}.pt'), map_location='cpu', weights_only=True)
        m = LogitTransformer().to(dev); m.load_state_dict(ck['state']); m.eval()
        out[held] = (m, np.asarray(ck['mu'], np.float32), np.asarray(ck['sd'], np.float32))
    return out


def stem_streams(models, held_list, D, dev):
    """(orig, sym) streams of the mean of the given fold models on one trial's (T, 4) logits."""
    X = ms_features(np.asarray(D, np.float64))
    s = [streams_of(*models[h][:1], X, *models[h][1:], dev) for h in held_list]
    return np.mean([a for a, _ in s], axis=0), np.mean([b for _, b in s], axis=0)


def main():
    torch.set_num_threads(2)
    dev = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    R.install_scorer()
    clf, info = zip(*[S.load_folds(e, 'causal') for e in CLF])
    dec = [S.load_folds(e, 'causal')[0] for e in DEC]
    bm = [S.load_folds(e, 'causal')[0] for e in BM]
    la = float(info[0][DS_KEYS[0]]['lookahead_s'])
    tab = {ds: F.corpus_table([v[ds] for v in dec], [v[ds] for v in clf], ds) for ds in DS_KEYS}
    models = stem_models(dev)
    # stem streams of every corpus trial for each fold model, aligned to the evidence times of the table
    SM = {h: {d: {} for d in DS_KEYS} for h in DS_KEYS}
    for d in DS_KEYS:
        for k, t in tab[d].items():
            Dl = np.stack([(c[d][k]['r0'] - c[d][k]['r1']) for c in clf], 1)
            te = clf[0][d][k]['t_end']
            for h in DS_KEYS:
                o, s = stem_streams(models, [h], Dl, dev)
                SM[h][d][k] = (bvec(dict(t_end=te, r0=o, r1=0 * o), t['ev']['t_end']),
                               bvec(dict(t_end=te, r0=s, r1=0 * s), t['ev']['t_end']))
        print('stem streams', d, flush=True)
    SMall = {d: {k: tuple(np.mean([SM[h][d][k][j] for h in DS_KEYS], axis=0) for j in (0, 1)) for k in tab[d]} for d in DS_KEYS}
    BMV = {d: {k: TB.bm_mean([b[d][k] for b in bm], t['ev']['t_end'], t['y'], SEEDS) for k, t in tab[d].items()} for d in DS_KEYS}
    real = {}
    for ds in ('AASD', 'Carta2026'):
        pre = 'aasd_c1' if ds == 'AASD' else f'ext_c1_{ds}'
        ed = [N.load(os.path.join(RES, f'{pre}_bestP_evidence_s{i}.pkl')) for i in SEEDS]
        ec = [N.load(os.path.join(RES, f'ext_clf_{ds}_w10b3sw2P_evidence_s{i}.pkl')) for i in SEEDS]
        rbm = [N.load(os.path.join(RES, f'ext_clf_{ds}_w10bmms3enhP_evidence_s{i}.pkl')) for i in SEEDS]
        real[ds] = {k: F.join(ed, ec, k) for k in ed[0]}
        for k, (x, e) in real[ds].items():
            e['_bm'] = TB.bm_mean([o[k] for o in rbm], e['t_end'], e['att'], SEEDS)
            Dl = np.stack([(c[k]['r0'] - c[k]['r1']).astype(np.float64) for c in ec], 1)
            o, s = stem_streams(models, list(DS_KEYS), Dl, dev)
            e['_stem'] = (bvec(dict(t_end=ec[0][k]['t_end'], r0=o, r1=0 * o), e['t_end']),
                          bvec(dict(t_end=ec[0][k]['t_end'], r0=s, r1=0 * s), e['t_end']))
        print('real', ds, flush=True)
    rows = []
    for outer in list(DS_KEYS) + ['ALL']:
        train = [d for d in DS_KEYS if d != outer] if outer != 'ALL' else list(DS_KEYS)
        parts = R.components([t for d in train for t in tab[d].values()])
        STM = SMall if outer == 'ALL' else SM[outer]
        P = {}
        for d in DS_KEYS:
            P[d] = {}
            for k, t in tab[d].items():
                a_, c_ = parts(t['x'])
                P[d][k] = dict(dec=a_, clf=c_, tr=TB.t_score(outer, TB.x16(t['x'], **X16)), bm=BMV[d][k],
                               stem=STM[d][k][0], ssym=STM[d][k][1])
        RP = {}
        if outer == 'ALL':
            for ds, v in real.items():
                RP[ds] = {}
                for k, (x, e) in v.items():
                    a_, c_ = parts(x)
                    RP[ds][k] = dict(dec=a_, clf=c_, tr=TB.t_score(outer, TB.x16(x, **X16)), bm=e['_bm'],
                                     stem=e['_stem'][0], ssym=e['_stem'][1])
        for m in ('tr', 'bm', 'stem', 'ssym'):
            sm = max(float(np.concatenate([P[d][k][m] * np.where(t['y'] == 0, 1., -1.) for d in train
                                           for k, t in tab[d].items()]).std()), 1e-8)
            for Q in (P, RP):
                for v in Q.values():
                    for pr in v.values():
                        pr[m] = pr[m] / sm
        for name, w in COMBOS.items():
            mix = lambda p: sum(c * p[m] for m, c in w.items())
            sg = np.concatenate([mix(P[d][k]) * np.where(t['y'] == 0, 1., -1.) for d in train for k, t in tab[d].items()])
            mu, sd = float(sg.mean()), float(sg.std())
            if mu <= 0 or sd < 1e-8:
                raise ValueError(f'invalid emissions {name} {outer}')
            base = {d: {k: dict(t['ev'], r0=mix(P[d][k]), r1=np.zeros(len(t['y'])), pre_switched=True)
                        for k, t in tab[d].items()} for d in DS_KEYS}
            for p in P_GRID:
                def integ(d, prm, p=p):
                    return e1_switch.integ_hmm(d, dict(p_stay=p, mu=prm['mu'], sd=prm['sd']))
                S.integ_hmm = integ; E.integ_hmm = integ
                if outer == 'ALL':
                    for ds, v in real.items():
                        ev = {k: dict(e, r0=mix(RP[ds][k]), r1=np.zeros(len(e['att']))) for k, (x, e) in v.items()}
                        rows.append(dict(combo=name, p_stay=p, ds=ds, kind='real', **E.score(ev, mu, sd, p, la)))
                else:
                    rows.append(dict(combo=name, p_stay=p, ds=outer, kind='synthetic',
                                     **S.score_dataset(outer, base, la, emis=(mu, sd), p_stay=p)))
                print({k: rows[-1][k] for k in ('combo', 'p_stay', 'ds', 'Acc', 'H')}, flush=True)
        pd.DataFrame(rows).to_csv(OUT.replace('.csv', '_partial.csv'), index=False)
    df = pd.DataFrame(rows).assign(metric='kappa_next_inclusive_provisional', calibration='classic_lodo')
    df.to_csv(OUT, index=False)
    lodo = df[df.kind == 'synthetic'].groupby(['combo', 'p_stay'])
    s = pd.DataFrame(dict(LODO_Acc=lodo.Acc.mean(), LODO_H=lodo.H.mean(), LODO_SDT=lodo.SDT.mean()))
    for ds in DS_KEYS:
        s[f'{ds}_Acc'] = df[df.ds == ds].set_index(['combo', 'p_stay']).Acc
    s['AVGC_H'] = df[df.ds == 'AVGC'].set_index(['combo', 'p_stay']).H
    for ds in ('AASD', 'Carta2026'):
        r = df[df.ds == ds].set_index(['combo', 'p_stay'])
        s[f'{ds}_Acc'] = r.Acc; s[f'{ds}_H'] = r.H; s[f'{ds}_SDT'] = r.SDT
    txt = ('4+4+4+4 (+ stem_ms96) ensembles, classic LODO calibration, kappa_next_inclusive_provisional\n'
           'stem on LODO = fold model without the outer dataset; on AASD / Carta = mean of the 5 fold models\n\n'
           + s.round(4).to_string() + '\n')
    open(OUT.replace('.csv', '_summary.txt'), 'w').write(txt); print(txt, flush=True)


if __name__ == '__main__':
    main()
