"""Assess diverse TRAIN schedules vs unchanged original held-out schedules.

Supports DirectNet-only and 4+4 fusion, with outer-dataset nested exclusion.
Uses the same subject group for all schedule variants when splitting stage 2.
"""
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 nested_stack_fusion as F
import score as S
from common import DS_KEYS
from common_exp import EXP, rows_of
from nested_stack_base import ROOT as CLF_ROOT, pair_name
from nested_stack_decoder import ROOT as DEC_ROOT
from nested_schedule_generate import ROOT, PROFILES, switch_mask

OUT=os.path.join(EXP,'results','research','nested_schedule_aug')


def zero_tied_decoder_windows(x, te, st):
    """A 50/50 time window has no preferred stream under a swap."""
    te=np.asarray(te[:len(x)],dtype=float)
    c=np.r_[0,np.cumsum(st)]
    lo=np.clip(np.round((te-1)*128).astype(int),0,len(st))
    hi=np.clip(np.round(te*128).astype(int),0,len(st))
    ties=2*(c[hi]-c[lo])==(hi-lo)
    x[ties,4:]=0.
    return x


def load(path):
    with open(path,'rb') as f:return pickle.load(f)


def profile_table(dec, outer, ds, profile, fusion):
    group='oof_'+ds if outer=='ALL' else pair_name(outer,ds)
    objs=[load(os.path.join(ROOT,group,f'seed{i}',profile,ds+'.pkl')) for i in range(4)]
    for i,obj in enumerate(objs):
        info=obj['info']; assert info['profile']==profile and info['seed']==i and info['scored_dataset']==ds
        expected = {ds} if outer == 'ALL' else {outer, ds}
        if set(info['excluded_datasets']) != expected:
            raise ValueError(f"invalid excluded datasets for {outer=}, {ds=}, {profile=}, seed={i}: "
                             f"{info['excluded_datasets']} != {sorted(expected)}")
    clf=[obj['evidence']['causal'] for obj in objs]
    table=[]
    for _,r in rows_of(ds).iterrows():
        k=r['key']; first=clf[0][k]
        for other in clf[1:]:
            v=other[k]
            assert np.array_equal(first['att'],v['att']) and np.array_equal(first['t_end'],v['t_end'])
            assert first['initial_swap']==v['initial_swap'] and np.array_equal(first['switch_times'],v['switch_times'])
        if fusion:
            st=switch_mask(int(r['n']),first['initial_swap'],first['switch_times'])
            x,e=F.join(dec,clf,k,st)
            # A half/half decoder window has no preferred stream. Existing
            # fusion's strict-majority tie rule is not swap-antisymmetric.
            x=zero_tied_decoder_windows(x,dec[0][k]['t_end'],st)
        else:
            x=np.stack([v[k]['r0']-v[k]['r1'] for v in clf],1).astype('f');e=first
        table.append(dict(x=x,y=e['att'],subject=r['subj_uid'],ds=ds,ev=e))
    return table


def original_table(dec,clf,ds,fusion):
    if fusion:return F.corpus_table(dec,clf,ds)
    subs=dict(zip(rows_of(ds)['key'],rows_of(ds)['subj_uid']))
    return {k:dict(x=np.stack([v[k]['r0']-v[k]['r1'] for v in clf],1).astype('f'),
                   y=e['att'],subject=subs[k],ds=ds,ev=e) for k,e in clf[0].items()}


def main(seed,variant,external):
    fusion=variant=='fusion';torch.set_num_threads(2)
    device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    os.makedirs(OUT,exist_ok=True)
    clf,info=zip(*[S.load_folds(exp,'causal') for exp in F.REF])
    dec,_=zip(*[S.load_folds(exp,'causal') for exp in F.DEC]) if fusion else (None,None)
    la=float(info[0][DS_KEYS[0]]['lookahead_s']);results=[]
    for outer in (['ALL'] if external else DS_KEYS):
        tab={};train=[]
        for ds in DS_KEYS:
            if outer=='ALL' or ds==outer:
                ec=[v[ds] for v in clf];ed=[v[ds] for v in dec] if fusion else None
            else:
                ec=[F.load_pair(CLF_ROOT,outer,ds,i) for i in range(4)]
                ed=[F.load_pair(DEC_ROOT,outer,ds,i) for i in range(4)] if fusion else None
            tab[ds]=original_table(ed,ec,ds,fusion)
            if ds!=outer:
                for profile in PROFILES:train.extend(profile_table(ed,outer,ds,profile,fusion))
        print('fit',variant,outer,'seed',seed,'diverse-trials',len(train),flush=True)
        model,scale=T.fit(train,seed,device)
        torch.save(dict(state=model.state_dict(),scale=scale.tolist(),outer=outer,variant=variant,
                        profiles=list(PROFILES)),os.path.join(OUT,f'model_{variant}_{outer}_s{seed}.pt'))
        # Calibrate both methods on ORIGINAL train schedule for a matched test.
        original=[t for ds in DS_KEYS if ds!=outer for t in tab[ds].values()]
        transform=F.baseline(original) if fusion else lambda x:x.mean(1)
        emis={}
        for method in ('transformer','baseline'):
            signed=np.concatenate([(T.predict(model,t['x'],scale,device) if method=='transformer' else transform(t['x']))
                                    *np.where(t['y']==0,1.,-1.) for t in original])
            mu,sd=float(signed.mean()),float(signed.std())
            if not np.isfinite(mu) or mu<=0 or not np.isfinite(sd) or sd<1e-6:raise ValueError(f'bad emission {mu} {sd}')
            emis[method]=(mu,sd)
        if not external:
            for method in emis:
                ev={d:{k:dict(t['ev'],r0=T.predict(model,t['x'],scale,device) if method=='transformer' else transform(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)
                results.append(dict(seed=seed,ds=outer,variant=variant,method=method,**r));print(results[-1],flush=True)
        else:
            for ds in ('AASD','Carta2026'):
                ec=[load(os.path.join(EXP,'results','research',f'ext_clf_{ds}_w10b3sw2P_evidence_s{i}.pkl')) for i in range(4)]
                if fusion:
                    dn='aasd_c1_bestP' if ds=='AASD' else f'ext_c1_{ds}_bestP'
                    ed=[load(os.path.join(EXP,'results','research',f'{dn}_evidence_s{i}.pkl')) for i in range(4)]
                    data={k:F.join(ed,ec,k) for k in ed[0]}
                else:
                    data={k:(np.stack([v[k]['r0']-v[k]['r1'] for v in ec],1).astype('f'),e) for k,e in ec[0].items()}
                for method in emis:
                    ev={k:dict(e,r0=T.predict(model,x,scale,device) if method=='transformer' else transform(x),
                               r1=np.zeros(len(x))) for k,(x,e) in data.items()}
                    r=E.score(ev,*emis[method],T.P,la)
                    results.append(dict(seed=seed,ds=ds,variant=variant,method=method,**r));print(results[-1],flush=True)
        label='real' if external else 'lodo'
        pd.DataFrame(results).to_csv(os.path.join(OUT,f'{variant}_{label}_s{seed}_partial.csv'),index=False)
    pd.DataFrame(results).to_csv(os.path.join(OUT,f'{variant}_{label}_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('--variant',choices=('direct','fusion'),required=True)
    p.add_argument('--external',action='store_true');a=p.parse_args();main(a.seed,a.variant,a.external)
