"""Training uses the frozen common-v3 semantic messages and native observations."""
import copy,json,math
from pathlib import Path
from evaluation.fourtask_common_v3.contract import messages,parse_action

def track_for(profile,row):
 return 'vision_only' if not row.get('audio_path') or not profile['audio'] else 'vision_mono' if (profile['kind']=='omni' or profile.get('native_audio_track')=='vision_mono') else 'vision_stereo'

def waveform(row,track):
 if track=='vision_only':return None
 import numpy as np,soundfile as sf
 from scipy.signal import resample_poly
 with sf.SoundFile(row['audio_path']) as f:sr=f.samplerate;wave=f.read(frames=sr*10,dtype='float32',always_2d=True)
 assert wave.shape==(sr*10,2) and np.isfinite(wave).all()
 if track=='vision_mono':
  g=math.gcd(sr,16000);return resample_poly(wave.mean(1),16000//g,sr//g).astype(np.float32)
 from omini.data.staqa_preprocessing import prepare_staqa_waveform
 return prepare_staqa_waveform(wave,sr).cpu().numpy()

def batch(row,actor):
 import torch
 from training.hvs_audio_fourtask.data import load_image
 track=track_for(actor.profile,row)
 decision=int(row['id'].rsplit(':',1)[-1])+int(row.get('recovery_prefix_steps',0))+1
 pose=list(map(int,row['pose']));answer=row['answers'][0]
 assert parse_action(answer,pose) is not None
 ms=messages(row['instruction'],pose,row['history_actions'],decision,track)
 pics=[load_image(d) for d in row['observations']]
 assert len(pics)==len(row['history_actions'])+1
 audio=waveform(row,track)
 if hasattr(actor,'prepare_inputs'):
  b=actor.prepare_inputs(ms,pics,audio);n=b['input_ids'].shape[1]
  end='<turn|>' if actor.kind=='gemma4' else '<|im_end|>'
  eid=actor.proc.tokenizer.convert_tokens_to_ids(end);assert eid is not None and eid!=actor.proc.tokenizer.unk_token_id
  target=actor.proc.tokenizer.encode(answer,add_special_tokens=False)+[eid]
  b['input_ids']=torch.cat([b['input_ids'],torch.tensor([target])],1);b['attention_mask']=torch.ones_like(b['input_ids'])
  # Qwen2-VL's rotary-position path consumes ``mm_token_type_ids`` when
  # present.  Different transformer minor versions expose this tensor under
  # slightly different names, so extend every sequence-aligned processor
  # field rather than only the two historical names.  Leaving one field at
  # the prompt length makes the attention mask longer than the token-type
  # tensor and crashes in get_rope_index during full-parameter SFT.
  for k,v in list(b.items()):
   if not hasattr(v,'ndim'):continue
   if v.ndim == 2 and v.shape[0] == 1 and v.shape[1] == n:
    b[k]=torch.cat([v,torch.zeros((1,len(target)),dtype=v.dtype,device=v.device)],1)
   elif v.ndim == 1 and v.shape[0] == n:
    b[k]=torch.cat([v,torch.zeros((len(target),),dtype=v.dtype,device=v.device)],0)
  b['labels']=b['input_ids'].clone();b['labels'][:,:n]=-100
  assert b['input_ids'].shape[1]<=4096
  return b
 native=copy.deepcopy(ms)
 for m in native:
  if actor.kind=='omni' and isinstance(m['content'],str):m['content']=[dict(type='text',text=m['content'])]
  if isinstance(m['content'],list):
   for c in m['content']:
    if c['type']=='audio':
     if actor.kind=='omni':c.clear();c.update(type='audio',audio='canonical_10s_recording')
     else:c.clear();c.update(type='text',text='<|audio_start|>'+'<|audio_pad|>'*41+'<|audio_end|>')
 kw=dict(images=pics,return_tensors='pt',padding=True)
 if actor.kind=='omni':
  kw['images_kwargs']=dict(min_pixels=3136,max_pixels=65536)
  if audio is not None:kw.update(audio=[audio],audio_kwargs=dict(sampling_rate=16000,truncation=False,max_length=480000,return_attention_mask=True))
 text=actor.proc.apply_chat_template(native,tokenize=False,add_generation_prompt=True)
 b=dict(actor.proc(text=[text],**kw));n=b['input_ids'].shape[1]
 # Some Qwen2-VL processor revisions return mm_token_type_ids before
 # placeholder expansion (shorter than input_ids).  Normalize it to the
 # actual prompt length before appending the supervised action tokens.
 for k,v in list(b.items()):
  if not hasattr(v,'ndim') or v.ndim not in (1,2):continue
  m=v.shape[-1]
  if (v.ndim==2 and v.shape[0]==1 or v.ndim==1) and m!=n:
   if m<n:
    pad=torch.zeros((*v.shape[:-1],n-m),dtype=v.dtype,device=v.device);b[k]=torch.cat([v,pad],-1)
   else:b[k]=v[..., :n]
 target=actor.proc.tokenizer.encode(answer,add_special_tokens=False)+[actor.proc.tokenizer.convert_tokens_to_ids('<|im_end|>')]
 b['input_ids']=torch.cat([b['input_ids'],torch.tensor([target])],1);b['attention_mask']=torch.ones_like(b['input_ids'])
 b['labels']=b['input_ids'].clone();b['labels'][:,:n]=-100
 if audio is not None and actor.kind!='omni':b['audio']=torch.from_numpy(audio).unsqueeze(0)
 assert b['input_ids'].shape[1]<=4096
 return b

def configure(model,training=True):
 model.train(training)
 for key in ['freeze_audio_encoder','freeze_llm','freeze_vision_tower','freeze_vision_merger']:
  if hasattr(model.config,key):setattr(model.config,key,False)
 core=getattr(model,'llm',model)
 if training:core.gradient_checkpointing_enable(gradient_checkpointing_kwargs={'use_reentrant':False})
 else:core.gradient_checkpointing_disable()
 for c in [core.config,getattr(core.config,'text_config',None)]:
  if c is not None:c.use_cache=not training

def save(model,path):
 from safetensors.torch import save_file
 path=Path(path);tmp=path.with_suffix('.tmp')
 save_file({k:v.detach().cpu().contiguous().clone() for k,v in model.state_dict().items()},str(tmp));tmp.replace(path)

def restore(model,path):
 from safetensors import safe_open
 import torch
 values=model.state_dict()
 with safe_open(str(path),framework='pt',device='cpu') as f:
  assert set(values)==set(f.keys())
  with torch.no_grad():
   for k,v in values.items():v.copy_(f.get_tensor(k).to(v))

class Optimizer:
 """FP32 master parameters/moments on host; train all model parameters."""
 def __init__(self,model,cfg):self.params=dict(model.named_parameters());self.state={};self.cfg=cfg
 def zero_grad(self):
  for p in self.params.values():p.grad=None
 def step(self,factor):
  import torch
  with torch.no_grad():
   for n,p in self.params.items():
    if p.grad is None:continue
    g=p.grad.detach().float().cpu()
    if n not in self.state:self.state[n]=dict(w=p.detach().float().cpu().clone(),m=torch.zeros_like(g),v=torch.zeros_like(g),t=0)
    s=self.state[n];s['t']+=1;s['m'].mul_(.9).add_(g,alpha=.1);s['v'].mul_(.999).addcmul_(g,g,value=.001)
    lr=self.cfg['vision_audio_learning_rate'] if any(k in n for k in ['visual.','audio_tower.','audio_encoder.','vision_tower.','vision_model.','multi_modal_projector.','encoder.']) else self.cfg['learning_rate']
    lr*=factor;den=s['v'].sqrt().div_(math.sqrt(1-.999**s['t'])).add_(1e-8)
    s['w'].mul_(1-lr*.01).addcdiv_(s['m'],den,value=-lr/(1-.9**s['t']));p.copy_(s['w'].to(p))