"""Nested 4-decoder + 4-DirectNet antisymmetric Transformer evaluation.

Pair-excluded base models generate meta-training features. Outer test features
use the established outer-held-out models. LDA and evidence normalization are
fit exclusively on meta-training data. Real sets use independently trained
all-five base models; no real labels enter fitting.
"""
import argparse
import os
import pickle

import numpy as np
import pandas as pd
import torch

import antisym_transformer_experiment as T
import eval_external as E
import score as S
from common import DS_KEYS, SEED
from common_exp import EXP, rows_of
from e1_switch import draw_switch_times
from eval_stem_external import REF
from fuse_evidence import OFF
from nested_stack_base import ROOT as CLF_ROOT, pair_name
from nested_stack_decoder import ROOT as DEC_ROOT

DEC = ['vlaai_ws__eaP_n5_t60_aug_cluster_onset_dom_xFUG_ptSPK'+s for s in ('','_s1','_s2','_s3')]
OUT = os.path.join(EXP,'results','research','nested_stack_fusion')


def load_pair(root, outer, ds, seed):
    path = os.path.join(root,pair_name(outer,ds),f'seed{seed}',ds+'.pkl')
    with open(path,'rb') as f: obj=pickle.load(f)
    info=obj['info']
    assert set(info['excluded_datasets']) == {outer,ds}
    assert set(info['train_datasets']).isdisjoint({outer,ds})
    assert info['scored_dataset']==ds and info['seed']==seed
    return obj['evidence']['causal']


def join(dec,clf,key,st=None):
    """Align four 3-target decoder deltas with four classifier logits."""
    te=dec[0][key]['t_end'].astype(float)
    ec=clf[0][key]
    n=min(len(te),len(ec['r0'])-OFF)
    if n <= 0 or not np.allclose(te[:n],ec['t_end'][OFF:OFF+n]+(4-OFF)*.25,atol=1e-3):
        raise ValueError(f'decoder/classifier timing mismatch: {key}')
    X=[]
    for e in clf:
        assert np.array_equal(e[key]['att'][OFF:OFF+n],ec['att'][OFF:OFF+n])
        X.append((e[key]['r0']-e[key]['r1'])[OFF:OFF+n])
    for e in dec:
        ed=e[key]
        assert np.allclose(ed['t_end'][:n],te[:n],atol=1e-3)
        delta=ed['r0f'][:n].astype(float)-ed['r1f'][:n].astype(float)
        if st is not None:
            c=np.r_[0,np.cumsum(st)]
            a=np.clip(np.round((te[:n]-1)*128).astype(int),0,len(st))
            b=np.clip(np.round(te[:n]*128).astype(int),0,len(st))
            delta *= np.where((c[b]-c[a])>(b-a)/2,-1.,1.)[:,None]
        X.extend(delta.T)
    return np.column_stack(X).astype('f'), dict(ec,att=ec['att'][OFF:OFF+n],t_end=ec['t_end'][OFF:OFF+n])


def corpus_table(dec,clf,ds):
    rng=np.random.default_rng(SEED+S.SCHED+DS_KEYS.index(ds))
    table={}
    for _,r in rows_of(ds).iterrows():
        n=int(r['n']); st=np.zeros(n,dtype=bool)
        for tt in draw_switch_times(rng,n/128):
            st[min(n-1,int(round(tt*128))):] ^= True
        rng.integers(0,2)
        x,e=join(dec,clf,r['key'],st)
        table[r['key']]=dict(x=x,y=e['att'],subject=r['subj_uid'],ds=ds,ev=e)
    return table


def baseline(trials):
    """Same LDA/normalization recipe as the 4+4 sw2 fusion baseline."""
    x=np.concatenate([t['x']*np.where(t['y']==0,1.,-1.)[:,None] for t in trials])
    weights=[]; scales=[]
    for i in range(4):
        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))
        weights.append(w/max((v@w).std(),1e-8))
        scales.append(max(x[:,i].std(),1e-8))
    zd=np.mean([x[:,4+3*i:7+3*i]@weights[i] for i in range(4)],axis=0)
    zc=np.mean([x[:,i]/scales[i] for i in range(4)],axis=0)
    sd=max(zd.std(),1e-8); sc=max(zc.std(),1e-8)
    def transform(z):
        a=np.mean([z[:,4+3*i:7+3*i]@weights[i] for i in range(4)],axis=0)/sd
        b=np.mean([z[:,i]/scales[i] for i in range(4)],axis=0)/sc
        return .5*(a+b)
    return transform


def main(seed,external):
    torch.set_num_threads(2); device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    os.makedirs(OUT,exist_ok=True)
    dec,_=zip(*[S.load_folds(e,'causal') for e in DEC])
    clf,info=zip(*[S.load_folds(e,'causal') for e in REF])
    la=float(info[0][DS_KEYS[0]]['lookahead_s'])
    rows=[]
    for outer in (['ALL'] if external else DS_KEYS):
        tab={}
        for ds in DS_KEYS:
            if outer=='ALL' or outer==ds:
                ed=[v[ds] for v in dec]; ec=[v[ds] for v in clf]
            else:
                ed=[load_pair(DEC_ROOT,outer,ds,i) for i in range(4)]
                ec=[load_pair(CLF_ROOT,outer,ds,i) for i in range(4)]
            tab[ds]=corpus_table(ed,ec,ds)
        trds=[d for d in DS_KEYS if d != outer]
        trials=[t for d in trds for t in tab[d].values()]
        print('fit',outer,'seed',seed,'datasets',trds,flush=True)
        model,scale=T.fit(trials,seed,device)
        torch.save(dict(state=model.state_dict(),scale=scale.tolist(),outer=outer,train=trds,n_features=16),
                   os.path.join(OUT,f'model_{outer}_s{seed}.pt'))
        base=baseline(trials)
        train_stream={m:[] for m in ('transformer','sw2_4plus4')}
        for t in trials:
            sg=np.where(t['y']==0,1.,-1.)
            train_stream['transformer'].append(T.predict(model,t['x'],scale,device)*sg)
            train_stream['sw2_4plus4'].append(base(t['x'])*sg)
        emis={m:(float(np.concatenate(v).mean()),float(np.concatenate(v).std())) for m,v in train_stream.items()}
        for name,(mu,sd) in emis.items():
            if not np.isfinite(mu) or mu<=0 or not np.isfinite(sd) or sd<1e-6:
                raise ValueError(f'invalid emission {outer} {name} {mu} {sd}')
        if not external:
            for method in emis:
                # score_dataset only reads outer data when emis is supplied, but
                # still constructs training arrays; populate all datasets.
                ev={d:{k:dict(t['ev'],r0=(T.predict(model,t['x'],scale,device) if method=='transformer' else base(t['x'])),
                              r1=np.zeros(len(t['y'])),pre_switched=True) for k,t in tab[d].items()} for d in DS_KEYS}
                r=S.score_dataset(outer,ev,la,emis=emis[method],p_stay=T.P)
                rows.append(dict(seed=seed,ds=outer,method=method,**r));print(rows[-1],flush=True)
        else:
            for ds in ('AASD','Carta2026'):
                dn='aasd_c1_bestP' if ds=='AASD' else f'ext_c1_{ds}_bestP'
                def open_ev(path):
                    with open(path,'rb') as f:return pickle.load(f)
                ed=[open_ev(os.path.join(EXP,'results','research',f'{dn}_evidence_s{i}.pkl')) for i in range(4)]
                ec=[open_ev(os.path.join(EXP,'results','research',f'ext_clf_{ds}_w10b3sw2P_evidence_s{i}.pkl')) for i in range(4)]
                data={k:join(ed,ec,k) for k in ed[0]}
                for method in emis:
                    ev={k:dict(e,r0=T.predict(model,x,scale,device) if method=='transformer' else base(x),
                               r1=np.zeros(len(x))) for k,(x,e) in data.items()}
                    r=E.score(ev,*emis[method],T.P,la)
                    rows.append(dict(seed=seed,ds=ds,method=method,**r));print(rows[-1],flush=True)
        pd.DataFrame(rows).to_csv(os.path.join(OUT,f"{'real' if external else 'lodo'}_s{seed}_partial.csv"),index=False)
    pd.DataFrame(rows).to_csv(os.path.join(OUT,f"{'real' if external else 'lodo'}_s{seed}.csv"),index=False)


if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('--seed',type=int,choices=(0,1),required=True)
    p.add_argument('--external',action='store_true');a=p.parse_args();main(a.seed,a.external)
