"""Create base logits excluding BOTH target datasets. One fit scores both.

Pretrained SparrKULee and Fuglsang are independent external training sets.
Results include explicit train/validation/excluded dataset manifests.
"""
import argparse
import os
import time
from types import SimpleNamespace

import numpy as np
import torch

import decoders
import direct_classifier as DC
from common import DS_KEYS, SEED
from common_exp import CFG, EXP, FS, load_trial, rows_of, save_pickle
from decoders import D, _targets
from e1_switch import draw_switch_times
from run_experiment import load_external

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


def pair_name(a, b):
    return '__'.join(sorted((a, b)))


def score_one(net, ds):
    rng = np.random.default_rng(SEED + DS_KEYS.index(ds))
    ev = {}
    for _, r in rows_of(ds).iterrows():
        tr = load_trial('eaP_n5_t60', r['key'])
        stim, x, att, n = _targets(tr), tr['eeg'], tr['att'].astype(int), int(r['n'])
        times = draw_switch_times(rng, n / 128)
        rng.integers(0, 2)
        st128 = np.zeros(n, dtype=bool)
        for tt in times:
            st128[min(n-1, int(round(tt * 128))):] ^= True
        idx = np.minimum(n-1, np.round((np.arange(len(x))/FS + tr['t0'])*128).astype(int))
        st = st128[idx]
        lg, starts = DC.logits(net, x, np.where(st[:, None, None], stim[:, ::-1], stim))
        truth = (att ^ st)[np.maximum(starts - DC.HOP, 0)]
        n10 = len(lg)//40
        ev[r['key']] = dict(r0=lg/2, r1=-lg/2, att=truth.astype(np.int8),
            t_end=(starts/FS+tr['t0']).astype(np.float32),
            r0_10=lg[:n10*40].reshape(n10,40).mean(1)/2,
            r1_10=-lg[:n10*40].reshape(n10,40).mean(1)/2,
            att10=(truth[:n10*40].reshape(n10,40).mean(1)>.5).astype(np.int8), pre_switched=True)
    return ev


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()
    if args.pair[0] == args.pair[1]:
        raise SystemExit('pair must contain distinct datasets')
    excluded = sorted(args.pair)
    outdir = os.path.join(ROOT, pair_name(*excluded), f'seed{args.seed}')
    paths = [os.path.join(outdir, ds+'.pkl') for ds 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)
    DC.W = 10*FS
    DC.POS0, DC.LAB = DC.W-DC.FUT-DC.HOP, DC.W-FS
    D['targets'] = ['env', 'onset', 'dom']
    D['augment'] = {**CFG['dnn_augment'], **CFG['aug_variants']['cluster'], 'clf_p_switch2': .5}
    D.update(model_blocks=3, train_seed=args.seed)
    rng = np.random.default_rng(CFG['seed'] + sum((DS_KEYS.index(d)+1)*100 for d in excluded))
    train, val, 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():
            (val if r['subject'] == vs else train).append(load_trial('eaP_n5_t60', r['key']))
    train += load_external(['Fuglsang2020'], 'eaP_n5_t60', print)
    for tr in train + val:
        tr['_S'] = _targets(tr)
    init = os.path.join(EXP, 'models', f'pretrain_spk_direct_clf_w10_b3_s{args.seed}.pt')
    opts = SimpleNamespace(backbone='vlaai_ws', p_switch=.5, zero_eeg=False, min_epochs=10)
    manifest = dict(excluded_datasets=excluded, train_datasets=train_ds,
                    train_external=['Fuglsang2020'], pretrain='SparrKULee',
                    validation_subjects=val_subject, seed=args.seed, lookahead_s=(DC.FUT+DC.HOP)/FS)
    print('manifest', manifest, 'train', len(train), 'val', len(val), flush=True)
    started = time.time()
    net, best = DC.fit(train, val, lambda x: print(x, flush=True), opts, init)
    del train, val
    os.makedirs(outdir, exist_ok=True)
    for ds, path in zip(excluded, paths):
        ev = score_one(net, ds)
        save_pickle(dict(evidence={'causal':ev}, info={**manifest, 'scored_dataset':ds,
                    'best_val':best, 'total_s':time.time()-started}), path)
        print('wrote', path, len(ev), flush=True)
    torch.save(net.state_dict(), os.path.join(outdir, 'model.pt'))


if __name__ == '__main__':
    main()
