"""S1: pretrain a DNN decoder on SparrKULee (single-speaker, ~85 subjects), then fine-tune per LODO fold with
run_experiment.py --init-from models/<name>.pt.

SparrKULee is never a test set and the five corpus datasets are not used here, so one pretrained network per seed
serves all five folds without leakage. Loss = Pearson with the attended targets (env + onset); early stopping on
held-out SparrKULee subjects (val loss = contrastive vs the mismatched envelope).
usage: python pretrain_sparrkulee.py --seed 0 [--decoder vlaai_ws --max-epochs 60 --model-override JSON --tag ""]
       -> models/pretrain_spk_<decoder><tag>_s<seed>.pt"""
import argparse
import json
import os
import time

import numpy as np
import torch

import decoders
from common_exp import CFG, EXP
from run_experiment import load_external


def log(m):
    print(f"{time.strftime('%F %T')} {m}", flush=True)


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--decoder", default="vlaai_ws")
    ap.add_argument("--prep", default="mat_reac")
    ap.add_argument("--max-epochs", type=int, default=60)
    ap.add_argument("--n-val-subjects", type=int, default=4)
    ap.add_argument("--model-override", default=None)
    ap.add_argument("--tag", default="")
    ap.add_argument("--targets", default="env,onset", help="comma list; dom / orel need GLIMPSE_THR=onorm and "
                    "external_data/SparrKULee/build_glimpse_spk.py (computed against the mismatched envelope)")
    ap.add_argument("--patience", type=int, default=None, help="early-stop patience in epochs (default config dnn.patience)")
    ap.add_argument("--lr-patience", type=int, default=None)
    ap.add_argument("--val-set", default="SparrKULee", help="early-stopping set: SparrKULee (held-out subjects) or an "
                    "external two-speaker AAD set such as Fuglsang2020 (attended vs ignored, closer to the target task)")
    ap.add_argument("--set", nargs="*", default=[], help="overrides of config dnn (e.g. model_blocks=6 model_kernels=128)")
    a = ap.parse_args()
    decoders.apply_overrides(a.set)
    if a.model_override:
        decoders.MODEL_OVERRIDES[a.decoder] = json.loads(a.model_override)
    if a.patience:
        decoders.D["patience"] = a.patience
    if a.lr_patience:
        decoders.D["lr_patience"] = a.lr_patience
    decoders.D.update(train_seed=a.seed, targets=a.targets.split(","), loss="pearson", max_epochs=a.max_epochs,
                      augment={**CFG["dnn_augment"], **CFG["aug_variants"]["cluster"]})
    torch.set_num_threads(4)
    tr = load_external(["SparrKULee"], a.prep, log)
    subs = sorted({t["key"].split("_")[1] for t in tr})
    val_s = set(np.random.default_rng(1234).choice(subs, a.n_val_subjects, replace=False))
    train = [t for t in tr if t["key"].split("_")[1] not in val_s]
    val = [t for t in tr if t["key"].split("_")[1] in val_s]
    if a.val_set != "SparrKULee":                     # never a LODO test set, so no leakage into any fold
        train += val
        val = load_external([a.val_set], a.prep, log)
    log(f"pretrain {a.decoder} seed {a.seed}: {len(train)} train runs ({len(subs) - len(val_s)} subjects), "
        f"{len(val)} val trials ({a.val_set if a.val_set != 'SparrKULee' else sorted(val_s)})")
    dec = decoders.make(a.decoder, 58, log)
    best = dec.fit(train, val, [(-1, -1)] * len(train))
    os.makedirs(os.path.join(EXP, "models"), exist_ok=True)
    out = os.path.join(EXP, "models", f"pretrain_spk_{a.decoder}{a.tag}_s{a.seed}.pt")
    torch.save(dec.net.state_dict(), out + ".tmp")
    os.replace(out + ".tmp", out)
    log(f"saved {out} (best val {best:+.4f})")
