"""Train decoder excluding a pair of datasets and generate evidence for both."""
import argparse
import os
import time

import numpy as np
import torch

import decoders
from common import DS_KEYS
from common_exp import CFG, EXP, evidence_from_features, load_trial, rows_of, save_pickle
from nested_stack_base import pair_name
from run_experiment import init_net, load_external

ROOT = os.path.join(EXP, 'folds', 'nested_stack_decoder')


def main():
    p = argparse.ArgumentParser()
    p.add_argument('--pair', nargs=2, choices=DS_KEYS, required=True)
    p.add_argument('--seed', type=int, choices=range(4), required=True)
    args = p.parse_args()
    excluded = sorted(args.pair)
    if excluded[0] == excluded[1]:
        raise SystemExit('pair must contain distinct datasets')
    outdir = os.path.join(ROOT, pair_name(*excluded), f'seed{args.seed}')
    paths = [os.path.join(outdir, d+'.pkl') for d in excluded]
    if all(os.path.exists(path) for path in paths):
        print('pair already complete', outdir, flush=True); return
    torch.set_num_threads(2)
    decoders.D.update(targets=['env','onset','dom'], train_seed=args.seed,
                      init_targets=['env','onset'],
                      augment={**CFG['dnn_augment'], **CFG['aug_variants']['cluster']})
    rng = np.random.default_rng(CFG['seed'] + sum((DS_KEYS.index(d)+1)*100 for d in excluded))
    train, val, meta, val_subject = [], [], [], {}
    train_ds = [d for d in DS_KEYS if d not in excluded]
    for ds in train_ds:
        rows = rows_of(ds)
        vs = rng.choice(sorted(rows.subject.unique()))
        val_subject[ds] = str(vs)
        for _, r in rows.iterrows():
            tr = load_trial('eaP_n5_t60', r['key'])
            if r['subject'] == vs:
                val.append(tr)
            else:
                train.append(tr); meta.append((int(r['did']),int(r['subject'])))
    ext = load_external(['Fuglsang2020'], 'eaP_n5_t60', print)
    train += ext; meta += [(-1,-1)] * len(ext)
    manifest = dict(excluded_datasets=excluded, train_datasets=train_ds,
                    train_external=['Fuglsang2020'], pretrain='SparrKULee',
                    validation_subjects=val_subject, seed=args.seed)
    print('manifest', manifest, 'train', len(train), 'val', len(val), flush=True)
    start = time.time()
    dec = decoders.make('vlaai_ws', train[0]['eeg'].shape[1], lambda x:print(x, flush=True))
    path = os.path.join(EXP, 'models', f'pretrain_spk_vlaai_ws_s{args.seed}.pt')
    init_net(dec, path, lambda x:print(x, flush=True))
    best = dec.fit(train,val,meta)
    del train,val,meta,ext
    os.makedirs(outdir, exist_ok=True)
    for ds,path in zip(excluded,paths):
        ev = {}
        for _,r in rows_of(ds).iterrows():
            tr = load_trial('eaP_n5_t60',r['key'])
            A,B0,B1 = dec.features(tr,'causal')
            ev[r['key']] = evidence_from_features(A,B0,B1,tr['att'],tr['t0'])
        save_pickle(dict(evidence={'causal':ev}, info={**manifest, 'scored_dataset':ds,
                    'lookahead_s':dec.lookahead_s,'best_val':best,'total_s':time.time()-start}),path)
        print('wrote',path,len(ev),flush=True)
    torch.save(dec.net.state_dict(),os.path.join(outdir,'model.pt'))


if __name__ == '__main__':
    main()
