"""Fit the second stage from pair-excluded logits and score each outer fold."""
import argparse
import os
import pickle

import numpy as np
import pandas as pd
import torch

import antisym_transformer_experiment as T
import score as S
from common import DS_KEYS
from common_exp import EXP, rows_of
from nested_stack_base import ROOT, pair_name
from eval_stem_external import REF


def load(path, outer, inner, seed):
    with open(path, 'rb') as f:
        f = pickle.load(f)
    info = f['info']
    assert set(info['excluded_datasets']) == {outer, inner}
    assert set(info['train_datasets']).isdisjoint({outer, inner})
    assert info['scored_dataset'] == inner and info['seed'] == seed
    return f['evidence']['causal']


def main(seed):
    torch.set_num_threads(2)
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    base, info = zip(*[S.load_folds(exp, 'causal') for exp in REF])
    lookahead = float(info[0][DS_KEYS[0]]['lookahead_s'])
    outdir = os.path.join(EXP, 'results', 'research', 'nested_stack')
    os.makedirs(outdir, exist_ok=True)
    scores = []
    for outer in DS_KEYS:
        tab = {}
        for ds in DS_KEYS:
            if ds == outer:
                evs = [b[ds] for b in base]
            else:
                evs = [load(os.path.join(ROOT, pair_name(outer, ds), f'seed{i}', ds+'.pkl'), outer, ds, i)
                       for i in range(4)]
            subs = dict(zip(rows_of(ds)['key'], rows_of(ds)['subj_uid']))
            tab[ds] = {}
            for k, e in evs[0].items():
                if not all(np.array_equal(e['att'], other[k]['att']) and np.array_equal(e['t_end'], other[k]['t_end']) for other in evs[1:]):
                    raise ValueError(f'mismatched schedules: {outer} {ds} {k}')
                x = np.stack([other[k]['r0']-other[k]['r1'] for other in evs], 1).astype('f')
                tab[ds][k] = dict(x=x, y=e['att'], subject=subs[k], ds=ds, ev=e)
        trds = [d for d in DS_KEYS if d != outer]
        trials = [t for ds in trds for t in tab[ds].values()]
        print('outer', outer, 'stage2 seed', seed, 'train 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),
                   os.path.join(outdir, f'model_{outer}_s{seed}.pt'))
        stream = {d: {k:T.predict(model, t['x'], scale, device) for k,t in tab[d].items()} for d in DS_KEYS}
        for method in ('transformer','mean4'):
            signed = np.concatenate([(stream[d][k] if method == 'transformer' else t['x'].mean(1)) * np.where(t['y']==0,1.,-1.)
                                      for d in trds for k,t in tab[d].items()])
            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'invalid emission {method}: {mu} {sd}')
            ev = {d:{k:dict(t['ev'], r0=stream[d][k] if method=='transformer' else t['x'].mean(1),
                            r1=np.zeros(len(t['y'])), pre_switched=True) for k,t in tab[d].items()} for d in DS_KEYS}
            result = S.score_dataset(outer, ev, lookahead, emis=(mu,sd), p_stay=T.P)
            scores.append(dict(seed=seed, ds=outer, method=method, **result))
            print(scores[-1], flush=True)
        pd.DataFrame(scores).to_csv(os.path.join(outdir, f'partial_s{seed}.csv'), index=False)
    pd.DataFrame(scores).to_csv(os.path.join(outdir, f'LODO_s{seed}.csv'), index=False)


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