"""R3: BMMS3 (pretrained 3-feature, EEG-enhanced BMMS classifier) inside the 4+4 reference, accuracy first.

Complements 387_bmms3_mix_4seed (which mixes BMMS3 into the 4+4 + rate-Transformer reference). Here, without the
Transformer, a fixed list of combinations decided in advance:
  ref        0.5 decoder + 0.5 DirectNet                       (the nested 4+4 sw2 reference)
  dec_bmms   0.5 decoder + 0.5 BMMS3                           (BMMS3 replaces DirectNet)
  clf_bmms   0.5 DirectNet + 0.5 BMMS3                         (no decoder)
  bmms       BMMS3 alone
  eq3        (decoder + DirectNet + BMMS3) / 3                  (4 + 4 + 4)
  b25        0.375 decoder + 0.375 DirectNet + 0.25 BMMS3
for HMM p_stay 0.998 / 0.95 / 0.90, and for the seed groups {0,1}, {2,3} (seed noise) and all four seeds.
Decoder / DirectNet: pair-excluded nested evidence and LDA as nested_stack_fusion.baseline. BMMS3 has no pair-excluded
fits yet: in a LODO fold its training-dataset evidence comes from LODO models that saw the outer dataset; it is only
standardised by a label-free std, but the HMM emissions use its signed evidence there -> LODO numbers with BMMS3 are
provisional (same caveat as bmms3_enhanced_mix_score.py). Real sets: all-five models, emissions from the corpus only.
Scorer: scorer_kappa_next_inclusive (provisional).
"""
import os
import numpy as np
import pandas as pd
import torch

import bmms3_enhanced_4seed_mix_score as B4
import e1_switch
import eval_external as E
import nested_schedule_eval as N
import r1_acc_decision_grid as R
import score as S
from common import DS_KEYS
from common_exp import EXP, rows_of

RES = os.path.join(EXP, 'results', 'research')
OUT = os.path.join(RES, 'r3_bmms3_combos.csv')
OUT_SUBJ = os.path.join(RES, 'r3_bmms3_combos_subjects.csv')
OUT_TXT = os.path.join(RES, 'r3_bmms3_combos_summary.txt')
BM = 'direct_clf__eaP_n5_t60_w10_bmms3enh_ptSPK_s{i}'
P_GRID = (0.998, 0.95, 0.90)
GROUPS = {'g01': (0, 1), 'g23': (2, 3), 'all4': (0, 1, 2, 3)}
COMBOS = {'ref': (.5, .5, 0.), 'dec_bmms': (.5, 0., .5), 'clf_bmms': (0., .5, .5), 'bmms': (0., 0., 1.),
          'eq3': (1 / 3, 1 / 3, 1 / 3), 'b25': (.375, .375, .25)}


def components(trials, idx):
    """nested_stack_fusion.baseline restricted to the seeds idx: standardised decoder-LDA and DirectNet parts."""
    x = np.concatenate([t['x'] * np.where(t['y'] == 0, 1., -1.)[:, None] for t in trials])
    W, Sc = {}, {}
    for i in idx:
        v = x[:, 4 + 3 * i:7 + 3 * i].astype(float)
        w = np.linalg.solve(np.cov(v.T) + np.eye(3) * 1e-8, v.mean(0))
        W[i] = w / max((v @ w).std(), 1e-8); Sc[i] = max(x[:, i].std(), 1e-8)
    zd = np.mean([x[:, 4 + 3 * i:7 + 3 * i] @ W[i] for i in idx], axis=0)
    zc = np.mean([x[:, i] / Sc[i] for i in idx], axis=0)
    sd, sc = max(zd.std(), 1e-8), max(zc.std(), 1e-8)

    def transform(z):
        return (np.mean([z[:, 4 + 3 * i:7 + 3 * i] @ W[i] for i in idx], axis=0) / sd,
                np.mean([z[:, i] / Sc[i] for i in idx], axis=0) / sc)
    return transform


def bm_vec(objs, t_end, y, idx):
    vs = []
    for i in idx:
        z, att = B4.bvec(objs[i], t_end)
        if not np.array_equal(np.asarray(att).astype(int), np.asarray(y).astype(int)):
            raise ValueError('BMMS label mismatch')
        vs.append(z)
    return np.mean(vs, axis=0)


def main(outers=None):
    torch.set_num_threads(2)
    R.install_scorer()
    clf, dec, la = R.load_reference()
    bm, _ = zip(*[S.load_folds(BM.format(i=i), 'causal') for i in range(4)])
    rows, srows = [], []
    for outer in (outers or list(DS_KEYS) + ['ALL']):
        tab = R.tables(outer, clf, dec)
        train = [d for d in DS_KEYS if d != outer]
        if outer == 'ALL':
            real = {ds: R.real_inputs(ds) for ds in ('AASD', 'Carta2026')}
            rbm = {ds: [N.load(os.path.join(RES, f'ext_clf_{ds}_w10bmms3enhP_evidence_s{i}.pkl')) for i in range(4)]
                   for ds in real}
        for g, idx in GROUPS.items():
            tr = components([t for d in train for t in tab[d].values()], idx)
            parts = {}
            for d in DS_KEYS:
                parts[d] = {}
                for k, t in tab[d].items():
                    a_, c_ = tr(t['x'])
                    b_ = bm_vec([bm[i][d][k] for i in range(4)], t['ev']['t_end'], t['y'], idx)
                    parts[d][k] = (a_, c_, b_)
            sb = float(np.concatenate([parts[d][k][2] for d in train for k in parts[d]]).std())  # label-free scale
            if outer == 'ALL':
                rparts = {}
                for ds in real:
                    rparts[ds] = {}
                    for k, (x, e) in real[ds].items():
                        a_, c_ = tr(x)
                        rparts[ds][k] = (a_, c_, bm_vec([rbm[ds][i][k] for i in range(4)], e['t_end'], e['att'], idx))
            for name, (wd, wc, wb) in COMBOS.items():
                mix = lambda pr: wd * pr[0] + wc * pr[1] + wb * pr[2] / sb
                signed = np.concatenate([mix(parts[d][k]) * np.where(t['y'] == 0, 1., -1.)
                                         for d in train for k, t in tab[d].items()])
                mu, sd = float(signed.mean()), float(signed.std())
                if mu <= 0 or sd < 1e-8:
                    raise ValueError('invalid emissions')
                base = {d: {k: dict(t['ev'], r0=mix(parts[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 in real:
                            ev = {k: dict(e, r0=mix(rparts[ds][k]), r1=np.zeros(len(e['att'])))
                                  for k, (x, e) in real[ds].items()}
                            out = E.score(ev, mu, sd, p, la); subs = R.subject_order_real(ev)
                            rows.append(dict(group=g, combo=name, p_stay=p, ds=ds, kind='real', **out))
                            srows += [dict(group=g, combo=name, p_stay=p, ds=ds, subject=str(s), acc=v)
                                      for s, v in zip(subs, R._CAP)]
                    else:
                        out = S.score_dataset(outer, base, la, emis=(mu, sd), p_stay=p)
                        subs = list(dict.fromkeys(rows_of(outer)['subj_uid']))
                        rows.append(dict(group=g, combo=name, p_stay=p, ds=outer, kind='synthetic', **out))
                        srows += [dict(group=g, combo=name, p_stay=p, ds=outer, subject=str(s), acc=v)
                                  for s, v in zip(subs, R._CAP)]
                    print({k: rows[-1][k] for k in ('group', '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')
    df['Kappa'] = np.maximum(0, 2 * df.Acc / 100 - 1)
    df.to_csv(OUT, index=False)
    pd.DataFrame(srows).to_csv(OUT_SUBJ, index=False)
    lodo = df[df.kind == 'synthetic'].groupby(['group', 'combo', 'p_stay'])
    s = pd.DataFrame(dict(LODO_Acc=lodo.Acc.mean(), LODO_H=lodo.H.mean()))
    s['AVGC_Acc'] = df[df.ds == 'AVGC'].set_index(['group', 'combo', 'p_stay']).Acc
    for ds in ('AASD', 'Carta2026'):
        r = df[df.ds == ds].set_index(['group', 'combo', 'p_stay'])
        s[f'{ds}_Acc'] = r.Acc; s[f'{ds}_H'] = r.H
    txt = ('R3 BMMS3 combinations (kappa_next_inclusive_provisional; BMMS3 LODO calibration provisional)\n\n'
           + s.round(4).to_string() + '\n')
    open(OUT_TXT, 'w').write(txt); print(txt, flush=True)


if __name__ == '__main__':
    main()
