"""Auxiliary local switch-rate loss on diverse-schedule nested evidence.

The rate head is training-only: it predicts log1p(switches/minute) in the
last 8 s, from the same past evidence. It is even under stream swapping.
The antisymmetric attention head and fixed HMM remain the inference pipeline.
"""
import argparse
import os
import random
import numpy as np
import torch
from torch import nn

import antisym_transformer_experiment as T
import nested_schedule_eval as S
from common_exp import EXP

AUX_WEIGHT=0.1


class RateNet(T.Net):
    def __init__(self,n_features=4):
        super().__init__(n_features)
        self.rate_head=nn.Linear(32,1)

    def heads(self,x):
        h=self.encoder(self.proj(torch.cat([x,-x],dim=0))+self.pos)[:,-1]
        a,b=h.chunk(2)
        attention=(self.head(a).squeeze(-1)-self.head(b).squeeze(-1))/2
        rate=self.rate_head((a+b)/2).squeeze(-1)
        return attention,rate

    def forward(self,x):
        return self.heads(x)[0]


def rate_target(y,i):
    """Count transitions on 32 observed hops ending at i; incomplete -> masked."""
    if i < T.W-1:return 0.,0.
    segment=y[i-T.W+1:i+1]
    count=int(np.count_nonzero(np.diff(segment)))
    duration=(T.W-1)*.25
    return float(np.log1p(60.*count/duration)),1.


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,rates,masks=[],[],[],[]
    for _ in range(n):
        tr=random.choice(groups[random.choice(ds)])
        i=int(rng.integers(0,len(tr['y'])))
        x=T.windows(tr['x'],[i])[0].copy()
        y=float(tr['y'][i]==0)
        rate,mask=rate_target(tr['y'],i)
        if augment:
            if rng.random()<.5:x,y=-x,1.-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,T.W-1)
                x[start:min(T.W,start+int(rng.integers(1,5)))]=0
        xs.append(x);ys.append(y);rates.append(rate);masks.append(mask)
    return tuple(torch.tensor(np.asarray(v),dtype=torch.float32) for v in (xs,ys,rates,masks))


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
    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,vr,vm=(v.to(device) for v in samples(valid,2048,rng,False))
    model=RateNet(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,rate,mask=(v.to(device) for v in samples(train,128,rng,True))
        lg,pr=model.heads(x)
        bce=nn.functional.binary_cross_entropy_with_logits(lg,y)
        loss_rate=((pr-rate).square()*mask).sum()/mask.sum().clamp_min(1.)
        loss=bce+AUX_WEIGHT*loss_rate
        opt.zero_grad();loss.backward();nn.utils.clip_grad_norm_(model.parameters(),1.);opt.step()
        if step%100==0:
            model.eval()
            with torch.no_grad():
                vl,rv=model.heads(vx)
                val_bce=nn.functional.binary_cross_entropy_with_logits(vl,vy).item()
                val_rate=(((rv-vr).square()*vm).sum()/vm.sum().clamp_min(1.)).item()
            print(f'seed={seed} step={step} bce={bce.item():.4f} rate_mse={loss_rate.item():.4f} val_bce={val_bce:.4f} val_rate_mse={val_rate:.4f}',flush=True)
            if val_bce<best-1e-4:
                best,stale=val_bce,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 selftest():
    torch.manual_seed(1);m=RateNet(16).eval();x=torch.randn(4,T.W,16)
    with torch.no_grad():a,r=m.heads(x);b,s=m.heads(-x)
    assert (a+b).abs().max()<1e-6 and (r-s).abs().max()<1e-6
    y=np.r_[np.zeros(16),np.ones(16)];rate,mask=rate_target(y,31)
    assert mask==1 and abs(rate-np.log1p(60/7.75))<1e-6
    assert rate_target(1-y,31)==(rate,mask) and rate_target(y,10)[1]==0
    # Changing labels after t cannot change this training target.
    after=np.r_[y,np.ones(20)];changed=after.copy();changed[32:]=0
    assert rate_target(after,31)==rate_target(changed,31)
    print('selftest passed: swapped attention/rate symmetry, past-only target, early mask',flush=True)


if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('--seed',type=int,choices=(0,1,2,3),default=0)
    p.add_argument('--variant',choices=('direct','fusion'),default='fusion')
    p.add_argument('--external',action='store_true');p.add_argument('--selftest',action='store_true');a=p.parse_args()
    selftest()
    if not a.selftest:
        T.fit=fit
        S.OUT=os.path.join(EXP,'results','research','nested_schedule_rate_aux')
        S.main(a.seed,a.variant,a.external)
