"""Fixed-weight mixture of trained rate-aux Transformer and 4+4 baseline.

All scaling, LDA and HMM emissions use only the outer training datasets.
LODO meta-training features come from pair-excluded first-stage models.
Real sets are never used for calibration or to select a weight. Report all
weights, with two stage-2 seeds, not a test-set-optimized result.
"""
import os
import numpy as np
import pandas as pd
import torch

import antisym_transformer_experiment as T
import eval_external as E
import nested_schedule_eval as N
import nested_stack_fusion as F
import score as S
from common import DS_KEYS
from common_exp import EXP
from nested_stack_base import ROOT as CLF_ROOT
from nested_stack_decoder import ROOT as DEC_ROOT
from switch_rate_aux_experiment import RateNet

WEIGHTS=(0.,.25,.5,.75,1.)  # proportion Transformer, fixed before scoring
P=0.998
OUT=os.path.join(EXP,'results','research','rate_aux_baseline_ensemble')


def model_for(outer,seed,device):
    path=os.path.join(EXP,'results','research','nested_schedule_rate_aux',f'model_fusion_{outer}_s{seed}.pt')
    ck=torch.load(path,map_location='cpu',weights_only=True)
    if ck['outer']!=outer or ck['variant']!='fusion':raise ValueError(f'wrong checkpoint {path}')
    model=RateNet(16).to(device);model.load_state_dict(ck['state']);model.eval()
    return model,np.asarray(ck['scale'],np.float32)


def signed_std(streams,table,train_ds):
    signed=np.concatenate([streams[d][k]*np.where(t['y']==0,1.,-1.)
                           for d in train_ds for k,t in table[d].items()])
    return float(signed.std())


def main(seed):
    torch.set_num_threads(2);os.makedirs(OUT,exist_ok=True)
    device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    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])
    lookahead=float(info[0][DS_KEYS[0]]['lookahead_s'])
    rows=[]
    for outer in list(DS_KEYS)+['ALL']:
        table={}
        for ds in DS_KEYS:
            if outer=='ALL' or outer==ds:
                ec=[v[ds] for v in clf];ed=[v[ds] for v in dec]
            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)]
            table[ds]=N.original_table(ed,ec,ds,True)
        train_ds=[d for d in DS_KEYS if d!=outer]
        trials=[t for d in train_ds for t in table[d].values()]
        baseline=F.baseline(trials)
        model,scale=model_for(outer,seed,device)
        streams={d:{k:(baseline(t['x']),T.predict(model,t['x'],scale,device))
                    for k,t in table[d].items()} for d in DS_KEYS}
        b={d:{k:v[0] for k,v in st.items()} for d,st in streams.items()}
        t={d:{k:v[1] for k,v in st.items()} for d,st in streams.items()}
        sb,st=signed_std(b,table,train_ds),signed_std(t,table,train_ds)
        if min(sb,st)<1e-8 or not np.isfinite([sb,st]).all():raise ValueError('invalid normalization')
        emissions={}
        for w in WEIGHTS:
            signed=np.concatenate([((1-w)*b[d][k]/sb+w*t[d][k]/st)*np.where(v['y']==0,1.,-1.)
                                   for d in train_ds for k,v in table[d].items()])
            mu,sd=float(signed.mean()),float(signed.std())
            if mu<=0 or sd<1e-8 or not np.isfinite([mu,sd]).all():raise ValueError('invalid emission')
            emissions[w]=(mu,sd)
        if outer!='ALL':
            for w in WEIGHTS:
                ev={d:{k:dict(v['ev'],r0=(1-w)*b[d][k]/sb+w*t[d][k]/st,
                              r1=np.zeros(len(v['y'])),pre_switched=True)
                       for k,v in table[d].items()} for d in DS_KEYS}
                result=S.score_dataset(outer,ev,lookahead,emis=emissions[w],p_stay=P)
                rows.append(dict(seed=seed,ds=outer,weight=w,**result));print(rows[-1],flush=True)
        else:
            for ds in ('AASD','Carta2026'):
                dn='aasd_c1_bestP' if ds=='AASD' else f'ext_c1_{ds}_bestP'
                ed=[N.load(os.path.join(EXP,'results','research',f'{dn}_evidence_s{i}.pkl')) for i in range(4)]
                ec=[N.load(os.path.join(EXP,'results','research',f'ext_clf_{ds}_w10b3sw2P_evidence_s{i}.pkl')) for i in range(4)]
                data={k:F.join(ed,ec,k) for k in ed[0]}
                pred={k:(baseline(x),T.predict(model,x,scale,device),e) for k,(x,e) in data.items()}
                for w in WEIGHTS:
                    ev={k:dict(e,r0=(1-w)*bb/sb+w*tt/st,r1=np.zeros(len(bb))) for k,(bb,tt,e) in pred.items()}
                    result=E.score(ev,*emissions[w],P,lookahead)
                    rows.append(dict(seed=seed,ds=ds,weight=w,**result));print(rows[-1],flush=True)
        pd.DataFrame(rows).to_csv(os.path.join(OUT,f'seed{seed}_partial.csv'),index=False)
    pd.DataFrame(rows).to_csv(os.path.join(OUT,f'seed{seed}.csv'),index=False)


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