"""Native visual backbones with 41 pretrained binaural tokens; no LoRA."""
import copy,json,sys
from pathlib import Path
import torch
from evaluation.fourtask_common_v3.new_actors import NewActor
from training.stereo_backbones_v1.common import configure
TOK='<|havs_stereo_pad|>'
class StereoModel(torch.nn.Module):
 def __init__(self,llm,encoder,token_id):
  super().__init__();self.llm=llm;self.encoder=encoder;self.token_id=token_id
  d=llm.get_input_embeddings().weight.shape[1]
  self.encoder_projector=torch.nn.Sequential(torch.nn.Linear(768,d),torch.nn.GELU(),torch.nn.Linear(d,d),torch.nn.LayerNorm(d)).to(device='cuda',dtype=torch.bfloat16)
  self.config=llm.config;self._audio=None;self.injections=0
  self._hook=llm.get_input_embeddings().register_forward_hook(self.inject)
 def inject(self,module,args,output):
  mask=args[0]==self.token_id;n=int(mask.sum())
  if not n:return output
  if self._audio is None:raise RuntimeError('Audio slots without an audio recording')
  assert n==self._audio.shape[0]*41,(n,self._audio.shape)
  self.injections+=1
  return output.masked_scatter(mask.unsqueeze(-1),self._audio.to(output.dtype))
 def encode(self,audio):
  if audio is None:return None
  assert audio.ndim==3 and tuple(audio.shape[1:])==(2,320000)
  if not any(p.requires_grad for p in self.encoder.parameters()):self.encoder.eval()
  return self.encoder_projector(self.encoder(audio.to(next(self.encoder.parameters()).dtype)).audio_tokens)
 def forward(self,audio=None,**kwargs):
  self._audio=self.encode(audio);before=self.injections
  try:
   result=self.llm(**kwargs)
   if audio is not None:assert self.injections>before,'Native backbone bypassed stereo embedding injection'
   return result
  finally:self._audio=None
 def generate(self,audio=None,**kwargs):
  self._audio=self.encode(audio);before=self.injections
  try:
   result=self.llm.generate(**kwargs)
   if audio is not None:assert self.injections>before
   return result
  finally:self._audio=None
class StereoActor(NewActor):
 def __init__(self,parent,out,cfg,checkpoint=None):
  super().__init__(parent,out,cfg['max_pixels'])
  sys.path.insert(0,cfg['omini_source'])
  from omini.models.st_audio_encoder import STAudioEncoder
  from omini.models.norm_fp32 import patch_norm_fp32
  initial=json.loads(Path(cfg['initial_audio_config']).read_text())
  enc=STAudioEncoder(audio_frontend='binaural',num_classes=initial['encoder_num_classes'],embed_dim=768,depth=12,num_heads=12,audio_bins=40,temporal_layers=initial['temporal_layers'],drop_path_rate=.1)
  state=torch.load(cfg['encoder_checkpoint'],map_location='cpu',weights_only=True);enc.load_state_dict(state.get('model',state),strict=True)
  enc=enc.to(device='cuda',dtype=torch.bfloat16);patch_norm_fp32(enc)
  # Preserve deliberately untied checkpoint embeddings when adding the audio token.
  # Some native configs declare tying although the published tensors differ.
  tied=self.model.get_input_embeddings().weight is self.model.get_output_embeddings().weight
  emb_sample=self.model.get_input_embeddings().weight[:4].detach().clone();head_sample=self.model.get_output_embeddings().weight[:4].detach().clone()
  if not tied:
   self.model.config.tie_word_embeddings=False
   if hasattr(self.model.config,'text_config'):self.model.config.text_config.tie_word_embeddings=False
  tok=self.proc.tokenizer;tok.add_tokens([TOK],special_tokens=True)
  n=max(len(tok),self.model.get_input_embeddings().weight.shape[0]);self.model.resize_token_embeddings(n,mean_resizing=False)
  assert torch.equal(emb_sample,self.model.get_input_embeddings().weight[:4]) and torch.equal(head_sample,self.model.get_output_embeddings().weight[:4]),'Token addition changed pretrained rows'
  assert tied==(self.model.get_input_embeddings().weight is self.model.get_output_embeddings().weight),'Token addition changed embedding binding'
  self.model=StereoModel(self.model,enc,tok.convert_tokens_to_ids(TOK));self.profile=dict(self.profile,audio=True,native_audio_track='vision_stereo')
  if checkpoint:
   from training.stereo_backbones_v1.common import restore
   restore(self.model,checkpoint)
 def prepare_inputs(self,msgs,pics,audio=None):
  msgs=copy.deepcopy(msgs);slots=0
  for m in msgs:
   if isinstance(m['content'],list):
    for c in m['content']:
     if c['type']=='audio':c.clear();c.update(type='text',text=TOK*41);slots+=1
  assert (slots==1)==(audio is not None),(slots,audio is None)
  b=super().prepare_inputs(msgs,pics,None)
  if audio is not None:
   assert audio.shape==(2,320000);b['audio']=torch.as_tensor(audio).unsqueeze(0)
   assert int((b['input_ids']==self.model.token_id).sum())==41
  return b