"""Exploratory antisymmetric logit Transformer; two seeds, LODO and real switches.

LODO caveat: base evidence is independently OOF by dataset, not nested OOF
for the entire stack. Thus an outer dataset may have trained a base model that
generated second-stage training evidence. Treat LODO as provisional.
"""
import argparse
import os
import pickle
import random

import numpy as np
import pandas as pd
import torch
from torch import nn

import eval_external as E
import score as S
from common import DS_KEYS
from common_exp import EXP, rows_of
from eval_stem_external import REF

W = 32  # eight seconds of evidence at 4 Hz
P = 0.998
OUT = os.path.join(EXP, 'results', 'research', 'antisym_transformer')


class Net(nn.Module):
    def __init__(self, n_features=4):
        super().__init__()
        self.proj = nn.Linear(n_features, 32)
        self.pos = nn.Parameter(torch.zeros(1, W, 32))
        layer = nn.TransformerEncoderLayer(32, 4, 64, dropout=0.1,
                                           batch_first=True, norm_first=True)
        self.encoder = nn.TransformerEncoder(layer, 2, enable_nested_tensor=False)
        self.head = nn.Linear(32, 1)

    def raw(self, x):
        return self.head(self.encoder(self.proj(x) + self.pos)[:, -1]).squeeze(-1)

    def forward(self, x):
        # In eval mode this is exactly odd. Duplicate a batch in one call.
        a, b = self.raw(torch.cat([x, -x], dim=0)).chunk(2)
        return (a - b) / 2


def windows(x, ix):
    ix = np.asarray(ix)
    positions = np.maximum(ix[:, None] - np.arange(W - 1, -1, -1), 0)
    return x[positions]


def samples(trials, n, rng, augment):
    ds = sorted(set(t['ds'] for t in trials))
    groups = {d: [t for t in trials if t['ds'] == d] for d in ds}
    xs, ys = [], []
    for _ in range(n):
        tr = random.choice(groups[random.choice(ds)])
        i = rng.integers(0, len(tr['y']))
        x = windows(tr['x'], [i])[0].copy()
        y = float(tr['y'][i] == 0)
        if augment:
            if rng.random() < .5:
                x, y = -x, 1.0 - y
            x *= rng.uniform(.8, 1.2)
            x += rng.normal(0, .08, x.shape)
            if rng.random() < .25:
                x[:, rng.integers(x.shape[1])] = 0
            if rng.random() < .2:
                start = rng.integers(0, W - 1)
                x[start:min(W, start + int(rng.integers(1, 5)))] = 0
        xs.append(x)
        ys.append(y)
    return torch.tensor(np.asarray(xs), dtype=torch.float32), torch.tensor(ys)


def fit(trials, seed, device):
    torch.manual_seed(seed); np.random.seed(seed); random.seed(seed)
    rng = np.random.default_rng(seed)
    groups = sorted(set((t['ds'], str(t['subject'])) for t in trials))
    val = {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 val]
    valid = [t for t in trials if (t['ds'], str(t['subject'])) in val]
    assert train and valid
    # Training scale is even in sign; no learned column bias in normalization.
    vals = np.concatenate([t['x'][::20] for t in train])
    scale = np.maximum(np.sqrt(np.mean(vals ** 2, axis=0)), 1e-3).astype(np.float32)
    train = [dict(t, x=t['x']/scale) for t in train]
    valid = [dict(t, x=t['x']/scale) for t in valid]
    vx, vy = samples(valid, 2048, rng, False)
    vx, vy = vx.to(device), vy.to(device)
    model = Net(train[0]['x'].shape[1]).to(device)
    opt = torch.optim.AdamW(model.parameters(), lr=3e-4, weight_decay=1e-3)
    best, state, stale = float('inf'), None, 0
    for step in range(1, 1001):
        model.train()
        x, y = samples(train, 128, rng, True)
        loss = nn.functional.binary_cross_entropy_with_logits(model(x.to(device)), y.to(device))
        opt.zero_grad(); loss.backward(); nn.utils.clip_grad_norm_(model.parameters(), 1.0); opt.step()
        if step % 100 == 0:
            model.eval()
            with torch.no_grad():
                vl = nn.functional.binary_cross_entropy_with_logits(model(vx), vy).item()
            print(f'seed={seed} step={step} train_bce={loss.item():.4f} val_bce={vl:.4f}', flush=True)
            if vl < best - 1e-4:
                best, stale = vl, 0
                state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
            else:
                stale += 1
                if stale >= 3:
                    break
    model.load_state_dict(state); model.eval()
    return model, scale


def predict(model, x, scale, device):
    out = []
    with torch.no_grad():
        for start in range(0, len(x), 512):
            ix = np.arange(start, min(start + 512, len(x)))
            xb = torch.from_numpy(windows(x / scale, ix)).to(device)
            out.append(model(xb).cpu().numpy())
    return np.concatenate(out).astype(np.float64)


def selftest():
    torch.manual_seed(3); m = Net().eval()
    x = torch.randn(5, W, 4)
    with torch.no_grad():
        a, b = m(x), m(-x)
    assert torch.max(torch.abs(a + b)).item() < 1e-6
    assert torch.max(torch.abs(m(torch.zeros_like(x)))).item() < 1e-6
    seq = np.random.default_rng(2).normal(size=(100, 4)).astype('f')
    before = windows(seq, np.arange(40))
    seq[40:] += 50
    assert np.array_equal(before, windows(seq, np.arange(40)))
    assert np.array_equal(windows(seq, [0])[0], np.repeat(seq[:1], W, axis=0))
    print('selftest: antisymmetry, zero evidence, causal window and boundary passed')


def main(seed, external_only=False):
    output = os.path.join(EXP, 'results', 'research', 'nested_stack_external') if external_only else OUT
    os.makedirs(output, exist_ok=True)
    torch.set_num_threads(2)
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    evs, info = zip(*[S.load_folds(exp, 'causal') for exp in REF])
    lookahead = float(info[0][DS_KEYS[0]]['lookahead_s'])
    corpus = {}
    for ds in DS_KEYS:
        subjects = dict(zip(rows_of(ds)['key'], rows_of(ds)['subj_uid']))
        corpus[ds] = {}
        for key, e in evs[0][ds].items():
            x = np.stack([ev[ds][key]['r0'] - ev[ds][key]['r1'] for ev in evs], 1).astype('f')
            corpus[ds][key] = dict(x=x, y=e['att'], subject=subjects[key], ds=ds, ev=e)
    external = {}
    for ds in ('AASD', 'Carta2026'):
        es = []
        for i in range(4):
            path = os.path.join(EXP, 'results', 'research', f'ext_clf_{ds}_w10b3sw2P_evidence_s{i}.pkl')
            with open(path, 'rb') as f: es.append(pickle.load(f))
        external[ds] = {k: dict(x=np.stack([e[k]['r0']-e[k]['r1'] for e in es], 1).astype('f'), ev=v)
                        for k, v in es[0].items()}
    rows = []
    for held in (['ALL'] if external_only else list(DS_KEYS) + ['ALL']):
        train_ds = [d for d in DS_KEYS if d != held]
        trials = [t for d in train_ds for t in corpus[d].values()]
        print(f'fit seed={seed} held={held}, trials={len(trials)}', flush=True)
        model, scale = fit(trials, seed, device)
        torch.save({'state': model.state_dict(), 'scale': scale.tolist(), 'train': train_ds},
                   os.path.join(output, f'seed{seed}_{held}.pt'))
        streams = {d: {k: predict(model, t['x'], scale, device) for k, t in corpus[d].items()} for d in DS_KEYS}
        signed = np.concatenate([streams[d][k] * np.where(t['y'] == 0, 1., -1.)
                                 for d in train_ds for k, t in corpus[d].items()])
        mu, sd = float(signed.mean()), float(signed.std())
        if not np.isfinite(mu) or not np.isfinite(sd) or mu <= 0 or sd < 1e-6:
            raise RuntimeError(f'invalid emissions {mu=} {sd=}')
        base_signed = np.concatenate([t['x'].mean(axis=1) * np.where(t['y'] == 0, 1., -1.)
                                      for d in train_ds for t in corpus[d].values()])
        bmu, bsd = float(base_signed.mean()), float(base_signed.std())
        if held != 'ALL':
            ev = {d: {k: dict(t['ev'], r0=streams[d][k], r1=np.zeros(len(t['y'])), pre_switched=True)
                      for k, t in corpus[d].items()} for d in DS_KEYS}
            result = S.score_dataset(held, ev, lookahead, emis=(mu, sd), p_stay=P)
            rows.append(dict(seed=seed, ds=held, method='transformer', **result))
            base = {d: {k: dict(t['ev'], r0=t['x'].mean(axis=1), r1=np.zeros(len(t['y'])), pre_switched=True)
                        for k, t in corpus[d].items()} for d in DS_KEYS}
            result = S.score_dataset(held, base, lookahead, emis=(bmu, bsd), p_stay=P)
            rows.append(dict(seed=seed, ds=held, method='mean4', **result))
        else:
            for ds, tab in external.items():
                ev = {k: dict(t['ev'], r0=predict(model, t['x'], scale, device), r1=np.zeros(len(t['x'])))
                      for k, t in tab.items()}
                result = E.score(ev, mu, sd, P, lookahead)
                rows.append(dict(seed=seed, ds=ds, method='transformer', **result))
                base = {k: dict(t['ev'], r0=t['x'].mean(axis=1), r1=np.zeros(len(t['x']))) for k, t in tab.items()}
                result = E.score(base, bmu, bsd, P, lookahead)
                rows.append(dict(seed=seed, ds=ds, method='mean4', **result))
        print(rows[-2:] if held != 'ALL' else rows[-4:], flush=True)
        pd.DataFrame(rows).to_csv(os.path.join(output, f'seed{seed}_partial.csv'), index=False)
    pd.DataFrame(rows).to_csv(os.path.join(output, f'seed{seed}.csv'), index=False)


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--seed', type=int, default=0)
    parser.add_argument('--selftest', action='store_true')
    parser.add_argument('--external-only', action='store_true')
    args = parser.parse_args()
    selftest()
    if not args.selftest:
        main(args.seed, args.external_only)
