"""Learn a global simplex mixture of baseline and rate-aux Transformer.

Each outer dataset is excluded from meta-training. Alpha is selected by
dataset-balanced logistic loss on the same held-out subjects used for early
stopping the saved Transformer; baseline calibration for this selection uses
only the other subjects. After selecting alpha, the unsupervised scales and
baseline LDA are refit on the available outer-training datasets. AASD/Carta
are never used for selection. This is post-hoc stacking, not end-to-end train.
"""
import argparse
import os
import numpy as np
import pandas as pd
import torch
from scipy.optimize import minimize_scalar

import antisym_transformer_experiment as T
import eval_external as E
import nested_schedule_eval as N
import nested_stack_fusion as F
import rate_aux_baseline_ensemble as M
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

OUT=os.path.join(EXP,'results','research','learn_rate_mix')
P=0.998


def group_split(trials,seed):
    groups=sorted({(t['ds'],str(t['subject'])) for t in trials})
    rng=np.random.default_rng(seed)
    validation={groups[i] for i in rng.choice(len(groups),max(1,len(groups)//6),replace=False)}
    train=[t for t in trials if (t['ds'],str(t['subject'])) not in validation]
    val=[t for t in trials if (t['ds'],str(t['subject'])) in validation]
    assert train and val and not ({(t['ds'],str(t['subject'])) for t in train}&validation)
    return train,val


def predictions(trials,baseline,model,scale,device):
    return [(v,baseline(v['x']),T.predict(model,v['x'],scale,device)) for v in trials]


def scales(pred):
    b=np.concatenate([bb*np.where(t['y']==0,1.,-1.) for t,bb,_ in pred])
    z=np.concatenate([tt*np.where(t['y']==0,1.,-1.) for t,_,tt in pred])
    return max(float(b.std()),1e-8),max(float(z.std()),1e-8)


def learn_alpha(pred,sb,st):
    by_ds={}
    for trial,base,tf in pred:
        sign=np.where(trial['y']==0,1.,-1.)
        by_ds.setdefault(trial['ds'],[]).append((sign*base/sb,sign*tf/st))
    arrays=[(np.concatenate([p[0] for p in arr]),np.concatenate([p[1] for p in arr])) for arr in by_ds.values()]
    def loss(w):
        return float(np.mean([np.logaddexp(0.,-((1-w)*b+w*z)).mean() for b,z in arrays]))
    result=minimize_scalar(loss,bounds=(0.,1.),method='bounded',options={'xatol':1e-5})
    if not result.success:raise RuntimeError('mixture optimization failed')
    choices=[0.,1.,float(result.x)]
    w=min(choices,key=loss)
    return w,loss(w),loss(0.),loss(1.)


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])
    la=float(info[0][DS_KEYS[0]]['lookahead_s']);rows=[]
    for outer in list(DS_KEYS)+['ALL']:
        tab={}
        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)]
            tab[ds]=N.original_table(ed,ec,ds,True)
        train_ds=[d for d in DS_KEYS if d!=outer]
        alltrain=[t for d in train_ds for t in tab[d].values()]
        tr,va=group_split(alltrain,seed)
        model,scale=M.model_for(outer,seed,device)
        base_train=F.baseline(tr)
        trp=predictions(tr,base_train,model,scale,device)
        sb,st=scales(trp)
        vap=predictions(va,base_train,model,scale,device)
        w,vl,v0,v1=learn_alpha(vap,sb,st)
        print(f'outer={outer} seed={seed} alpha={w:.6f} val_bce={vl:.6f} base={v0:.6f} transformer={v1:.6f} train_groups={len(set((x["ds"],str(x["subject"])) for x in tr))} val_groups={len(set((x["ds"],str(x["subject"])) for x in va))}',flush=True)
        # Refit train-only baseline/calibration after alpha selection.
        base=F.baseline(alltrain)
        predictions_by_ds={d:{k:(base(t['x']),T.predict(model,t['x'],scale,device)) for k,t in tab[d].items()} for d in DS_KEYS}
        allpred=[(tab[d][k],bb,tt) for d in train_ds for k,(bb,tt) in predictions_by_ds[d].items()]
        sb,st=scales(allpred)
        signed=np.concatenate([((1-w)*bb/sb+w*tt/st)*np.where(t['y']==0,1.,-1.) for t,bb,tt in allpred])
        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 emissions')
        metadata=dict(seed=seed,alpha=w,val_bce=vl,val_bce_baseline=v0,val_bce_transformer=v1)
        if outer!='ALL':
            ev={d:{k:dict(t['ev'],r0=(1-w)*predictions_by_ds[d][k][0]/sb+w*predictions_by_ds[d][k][1]/st,
                           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=(mu,sd),p_stay=P)
            rows.append(dict(ds=outer,**metadata,**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'
                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]}
                ev={k:dict(e,r0=(1-w)*base(x)/sb+w*T.predict(model,x,scale,device)/st,
                           r1=np.zeros(len(x))) for k,(x,e) in data.items()}
                r=E.score(ev,mu,sd,P,la)
                rows.append(dict(ds=ds,**metadata,**r));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)


def selftest():
    ones=np.ones(100);zeros=np.zeros(100)
    groups=[(dict(ds='synthetic',y=zeros),ones*2,-ones)]
    a,*_=learn_alpha(groups,1.,1.);assert a<1e-3
    groups=[(dict(ds='synthetic',y=zeros),-ones,ones*2)]
    a,*_=learn_alpha(groups,1.,1.);assert a>1-1e-3
    print('selftest: optimizer learns either endpoint; signs swap correctly',flush=True)


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