"""Nested diverse-schedule Transformer: masked short histories and random crops.

Changes only Transformer input handling/training, not first-stage models or
switch-rate objective. All windows are past-only. A truncated input receives
no rate loss unless the complete 32-frame label interval is visible.
"""
import argparse,os,random
import numpy as np
import torch
from torch import nn
import antisym_transformer_experiment as T
import nested_schedule_eval as S
import switch_rate_aux_experiment as R
from common_exp import EXP

OUT=os.path.join(EXP,'results','research','nested_schedule_masked_rate')

class MaskedRateNet(R.RateNet):
 def heads(self,x,mask=None):
  if mask is None:mask=torch.zeros(x.shape[:2],dtype=torch.bool,device=x.device)
  assert mask.shape==x.shape[:2] and not mask[:,-1].any()
  z=self.proj(torch.cat((x,-x),0))+self.pos
  m=torch.cat((mask,mask),0)
  h=self.encoder(z,src_key_padding_mask=m)[:,-1];a,b=h.chunk(2)
  return (self.head(a).squeeze(-1)-self.head(b).squeeze(-1))/2,self.rate_head((a+b)/2).squeeze(-1)
 def forward(self,x,mask=None):return self.heads(x,mask)[0]

def make_window(seq,i,length):
 length=min(int(length),i+1,T.W);assert length>=1
 x=np.zeros((T.W,seq.shape[1]),np.float32);x[-length:]=seq[i-length+1:i+1]
 m=np.ones(T.W,dtype=bool);m[-length:]=False
 return x,m

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,rs,rms,ms=[],[],[],[],[]
 for _ in range(n):
  tr=random.choice(groups[random.choice(ds)]);i=int(rng.integers(len(tr['y'])))
  length=int(rng.integers(1,T.W+1)) if augment and rng.random()<.5 else T.W
  length=min(length,i+1);x,mask=make_window(tr['x'],i,length)
  y=float(tr['y'][i]==0);rate,rm=R.rate_target(tr['y'],i)
  if length<T.W:rm=0.
  if augment:
   if rng.random()<.5:x,y=-x,1.-y
   x*=rng.uniform(.8,1.2);x+=rng.normal(0,.08,x.shape).astype('f')
   if rng.random()<.25:x[:,rng.integers(x.shape[1])]=0
   if rng.random()<.2:
    start=int(rng.integers(0,T.W-1));x[start:min(T.W,start+int(rng.integers(1,5)))]=0
  xs.append(x);ys.append(y);rs.append(rate);rms.append(rm);ms.append(mask)
 return (torch.as_tensor(np.array(xs),dtype=torch.float32),torch.as_tensor(ys,dtype=torch.float32),
         torch.as_tensor(rs,dtype=torch.float32),torch.as_tensor(rms,dtype=torch.float32),torch.as_tensor(np.array(ms),dtype=torch.bool))

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,vpad=(v.to(device) for v in samples(valid,2048,rng,False))
 model=MaskedRateNet(train[0]['x'].shape[1]).to(device);opt=torch.optim.AdamW(model.parameters(),lr=3e-4,weight_decay=1e-3)
 best=float('inf');state=None;stale=0
 for step in range(1,1001):
  model.train();x,y,rate,rm,pad=(v.to(device) for v in samples(train,128,rng,True))
  lg,pr=model.heads(x,pad);bce=nn.functional.binary_cross_entropy_with_logits(lg,y)
  lr=((pr-rate).square()*rm).sum()/rm.sum().clamp_min(1.);loss=bce+R.AUX_WEIGHT*lr
  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,vpad);vb=nn.functional.binary_cross_entropy_with_logits(vl,vy).item()
    vrl=(((rv-vr).square()*vm).sum()/vm.sum().clamp_min(1.)).item()
   print(f'seed={seed} step={step} bce={bce.item():.4f} rate_mse={lr.item():.4f} val_bce={vb:.4f} val_rate_mse={vrl:.4f}',flush=True)
   if vb<best-1e-4:best=vb;stale=0;state={k:v.detach().cpu().clone() for k,v in model.state_dict().items()}
   else:
    stale+=1
    if stale>=3:break
 assert state is not None;model.load_state_dict(state);model.eval();return model,scale

def predict(model,x,scale,device):
 x=x/scale;out=[]
 with torch.no_grad():
  for start in range(0,len(x),512):
   windows=[make_window(x,i,T.W) for i in range(start,min(start+512,len(x)))]
   xx=torch.from_numpy(np.stack([v[0] for v in windows])).to(device)
   masks=torch.from_numpy(np.stack([v[1] for v in windows])).to(device)
   out.append(model(xx,masks).cpu().numpy())
 return np.concatenate(out).astype(np.float64)

def selftest():
 torch.manual_seed(9);m=MaskedRateNet(16).eval();rng=np.random.default_rng(8)
 x=rng.normal(size=(80,16)).astype('f');scale=np.ones(16,'f')
 a=predict(m,x,scale,'cpu');b=predict(m,-x,scale,'cpu');assert np.max(np.abs(a+b))<1e-6
 changed=x.copy();changed[40:]+=10;assert np.array_equal(a[:40],predict(m,changed,scale,'cpu')[:40])
 xx,mask=make_window(x,5,6);alt=xx.copy();alt[mask]=12345
 with torch.no_grad():
  ma=torch.from_numpy(mask[None]);p=m(torch.from_numpy(xx[None]),ma);q=m(torch.from_numpy(alt[None]),ma)
 assert torch.allclose(p,q,atol=1e-6)
 prefix=rng.normal(size=(40,16)).astype('f');withprefix=predict(m,np.r_[prefix,x],scale,'cpu')[40:]
 assert np.max(np.abs(a[T.W-1:]-withprefix[T.W-1:]))<1e-6
 # Exact label-time alignment and partial windows have no rate target.
 tr={'ds':'x','subject':'s','x':x,'y':np.r_[np.zeros(40),np.ones(40)]}
 random.seed(1);sample=samples([tr],100,rng,True);assert not sample[-1][:,-1].any()
 print('selftest PASS: masked tokens ignored, swap symmetry, past only, full-window shift, nonempty history',flush=True)

if __name__=='__main__':
 p=argparse.ArgumentParser();p.add_argument('--seed',type=int,choices=(0,1),default=0);p.add_argument('--external',action='store_true');p.add_argument('--selftest',action='store_true');a=p.parse_args()
 torch.set_num_threads(2);selftest()
 if not a.selftest:
  T.fit=fit;T.predict=predict;S.OUT=OUT;S.main(a.seed,'fusion',a.external)
