"""Math-only SP admission, exact-token packing and replicated prompt-only training."""
import argparse
import array
from dataclasses import asdict
import datetime
import fcntl
import hashlib
import importlib.metadata
import json
import os
from pathlib import Path
import random
import shutil
import signal
import sys
import time

from runtime import atomic_json, require_allocation, sha256

BASE=Path(__file__).resolve().parents[1]
REPO=BASE.parents[1]
DOMAIN=os.environ['M2RL_RETRAIN_DOMAIN']
assert DOMAIN in ('math','code')
CONFIG=BASE/'configs/math-sp-freqinit-v1.json'
assert DOMAIN == 'math', 'Only Math FREQINIT is authorized'

def read(path): return json.loads(Path(path).read_text())
def digest(value): return hashlib.sha256(json.dumps(value,sort_keys=True,separators=(',',':')).encode()).hexdigest()
def config():
    from retrain_balanced_train_v1 import config as baseline_config
    cfg=read(CONFIG);baseline=baseline_config()
    if sha256(cfg['source_config'])!=cfg['source_config_sha256'] or cfg['source_config_sha256']!='faceebfad55bbdac11b5477a7154c0c83fc462d5e41982c2498c913a3cb03261':
        raise ValueError('Frozen baseline config changed')
    if sha256(cfg['experiment_authorization'])!=cfg['experiment_authorization_sha256']:
        raise ValueError('Direct user authorization changed')
    allowed={'schema','learning_rate','prompt_initialization','evaluation_updates','output','local_backup','source_config','source_config_sha256','experiment_authorization','experiment_authorization_sha256'}
    for key in set(cfg)|set(baseline):
        if key not in allowed and cfg.get(key)!=baseline.get(key):
            raise ValueError('Unrequested configuration change: '+key)
    if cfg['learning_rate']!=0.01 or cfg['evaluation_updates']!=[120,140,160,180,200]:
        raise ValueError('User-approved LR or evaluation grid changed')
    if cfg['output']!='/data/users/zhenzhang/projects/m2rl-issue18-execution/math-freqinit-v1/train-math' or cfg['local_backup']!='/data/users/zhenzhang/projects/m2rl-issue18-execution/local-backups/math-freqinit-v1/math':
        raise ValueError('Refuse writes outside the isolated new run')
    return cfg

def initialize_frequency_prompt(student,tokenizer,cfg):
    import torch
    spec=cfg['prompt_initialization']
    assert spec['method']=='training_token_frequency' and cfg['prompt_length']==256
    assert sha256(spec['manifest'])==spec['manifest_sha256']
    manifest=read(spec['manifest'])
    assert sha256(Path(cfg['model_path'])/'tokenizer.json')==manifest['tokenizer_sha256']
    ids=manifest['token_ids']
    assert len(ids)==len(set(ids))==256
    assert not(set(ids)&set(tokenizer.all_special_ids))
    assert manifest['ordering']=='frequency descending, token ID ascending for ties'
    assert manifest['packed_manifest_sha256']==sha256(Path(cfg['packed_data'])/'manifest.json')
    weight=student.get_input_embeddings().weight
    prompt=weight.detach().index_select(0,torch.tensor(ids,device=weight.device)).float().clone()
    receipt=read(BASE/'reports/math-freqinit-v1/INITIAL-TENSOR.json')
    assert list(prompt.shape)==receipt['shape']
    assert hashlib.sha256(prompt.cpu().contiguous().numpy().tobytes()).hexdigest()==receipt['fp32_bytes_sha256']
    return prompt

def system_scaffold(tokenizer):
    header=tokenizer.encode('<|im_start|>system\n',add_special_tokens=False)
    close=tokenizer.encode('<|im_end|>\n',add_special_tokens=False)
    example=[{'role':'user','content':'scaffold-check'}]
    kw=dict(tokenize=True,add_generation_prompt=True,enable_thinking=True)
    original=tokenizer.apply_chat_template(example,**kw)
    empty=tokenizer.apply_chat_template([{'role':'system','content':''},*example],**kw)
    if empty!=header+close+original: raise ValueError('empty system scaffold does not match pinned chat template')
    return header,close

def add_system(input_ids,prefix_tokens,header,close):
    ids=list(input_ids)
    if ids[:len(header)]==header: return ids,prefix_tokens,len(header),False
    # Refuse ambiguous non-system messages instead of inserting at a guessed boundary.
    if ids[:3]!=[151644,872,198]: raise ValueError('expected original user or system role header')
    return header+close+ids,prefix_tokens+len(header)+len(close),len(header),True

def validate_data(cfg):
    directory=Path(cfg['packed_data']);manifest=read(directory/'manifest.json')
    if manifest['source_manifest_sha256']!=cfg['data_manifest_sha256']:raise ValueError('packed dataset identity changed')
    for name,key in [('tokens.uint32','tokens_sha256'),('index.json','index_sha256')]:
        if sha256(directory/name)!=manifest[key]:raise ValueError('packed data changed '+name)
    return directory,manifest

def balanced_ranks(indices,entries,world):
    groups=[[] for _ in range(world)];loads=[0]*world;cap=len(indices)//world
    if len(indices)%world:raise ValueError('global batch must divide DP size')
    for index in sorted(indices,key=lambda i:(-entries[i]['length'],i)):
        rank=min((r for r in range(world) if len(groups[r])<cap),key=lambda r:(loads[r],r))
        groups[rank].append(index);loads[rank]+=entries[index]['length']
    return groups

def code_identity():
    files=[Path(__file__),BASE/'scripts/runtime.py',REPO/'src/soft_prompt_distillation/training.py',REPO/'src/soft_prompt_distillation/m2rl_training.py',REPO/'src/soft_prompt_distillation/objective.py']
    return {str(p.relative_to(REPO)):sha256(p) for p in files}

def checkpoint_copy(cfg,path):
    target=Path(cfg['local_backup'])/'checkpoints'/path.name
    if target.exists():
        if sha256(target/'state.pt')!=sha256(path/'state.pt'):raise ValueError('backup identity conflict')
    else:
        temporary=target.with_name('.'+target.name+'.tmp');temporary.parent.mkdir(parents=True,exist_ok=True)
        shutil.copytree(path,temporary)
        for name in ('state.pt','commit.json'):
            if sha256(temporary/name)!=sha256(path/name):raise ValueError('checkpoint backup verification failed')
        temporary.rename(target)
    atomic_json(path/'backup-receipt.json',dict(status='PASS_LOCAL_COMPLETE_STATE_COPY_SHA256',path=str(target),state_sha256=sha256(target/'state.pt'),commit_sha256=sha256(target/'commit.json')))

def train(smoke=False):
    allocation=require_allocation();cfg=config()
    if not smoke:
        training_proof=read(BASE/'evidence/math-sp-freqinit-gpu-smoke-v1.json')
        if training_proof['hashes']['code']!=digest(code_identity()) or training_proof['hashes']['config']!=sha256(CONFIG):
            raise ValueError('GPU training smoke code/config no longer current')
    preflight=read(BASE/'reports/math-freqinit-v1/PREFLIGHT.json')
    if preflight['status']!='PASS' or preflight['configs'][DOMAIN]!=sha256(CONFIG):
        raise ValueError('CPU preflight is not current')
    import numpy as np
    import torch
    import torch.distributed as dist
    from transformers import AutoModelForCausalLM, AutoTokenizer
    from types import SimpleNamespace
    from soft_prompt_distillation.training import SoftPromptModel,TrainingBatch,batch_indices_for_update,accumulate_response_loss,finish_prompt_update,initialize_prompt_embeddings
    from soft_prompt_distillation.m2rl_training import make_m2rl_optimizer,capture_rank_state,gather_rank_states,save_checkpoint,restore_checkpoint
    local_rank=int(os.environ['LOCAL_RANK']);rank=int(os.environ['RANK']);world=int(os.environ['WORLD_SIZE'])
    if world!=cfg['training_dp']:raise ValueError('training topology must be DP4 TP1')
    torch.cuda.set_device(local_rank);device=torch.device('cuda',local_rank)
    dist.init_process_group('nccl',device_id=device,timeout=datetime.timedelta(minutes=45))
    directory,manifest=validate_data(cfg);entries=read(directory/'index.json');tokens=np.memmap(directory/'tokens.uint32',dtype='<u4',mode='r')
    run=Path(cfg['output'])/('smoke' if smoke else 'production');run.mkdir(parents=True,exist_ok=True)
    lock=None
    if rank==0:
        lock=(run/'.trainer.lock').open('w');fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
    seed=cfg['seed'];random.seed(seed);np.random.seed(seed);torch.manual_seed(seed);torch.cuda.manual_seed_all(seed)
    student=AutoModelForCausalLM.from_pretrained(cfg['model_path'],local_files_only=True,torch_dtype=torch.bfloat16,attn_implementation=cfg['attention_implementation']).to(device)
    tokenizer=AutoTokenizer.from_pretrained(cfg['model_path'],local_files_only=True)
    prompt=initialize_frequency_prompt(student,tokenizer,cfg)
    wrapper=SoftPromptModel(student,prompt,activation_checkpointing=True,cross_entropy_backend='liger_fused',loss_normalization='sequence')
    optimizer=make_m2rl_optimizer(wrapper.prompt_parameter)
    identities=dict(code=digest(code_identity()),config=sha256(CONFIG),data=sha256(directory/'manifest.json'),topology=digest(dict(dp=world,tp=1,micro_batch=1,gradient_reduction='sum')))
    versions={p:importlib.metadata.version(p) for p in ('torch','transformers','liger-kernel')}
    start=1
    committed=sorted((run/'checkpoints').glob('update-*')) if (run/'checkpoints').exists() else []
    if committed:
        restored=restore_checkpoint(committed[-1],prompt=wrapper.prompt_parameter,optimizer=optimizer,hashes=identities,rank=rank,world_size=world)
        start=restored['update']+1
    if rank==0:
        atomic_json(run/'run.json',dict(status='GPU_SMOKE_RUNNING' if smoke else 'TRAINING',allocation=allocation,started_at=time.time(),start_update=start,hashes=identities,code=code_identity(),versions=versions,world_size=world,trainable_parameters=wrapper.prompt_parameter.numel(),backbone_trainable=0,config=cfg))
    # A smoke is a separate real global batch64 update, including the longest whole candidate.
    # Its optimizer/RNG/data path is isolated and never reused as production initialization.
    updates=1 if smoke else cfg['updates']
    began=time.monotonic();stop=[False]
    signal.signal(signal.SIGTERM,lambda *_:stop.__setitem__(0,True))
    signal.signal(signal.SIGINT,lambda *_:stop.__setitem__(0,True))
    for update in range(start,updates+1):
        global_indices=batch_indices_for_update(dataset_size=len(entries),effective_batch_size=64,batch_seed=seed,update=update)
        if smoke:
            longest=max(range(len(entries)),key=lambda i:entries[i]['length'])
            if longest not in global_indices:global_indices[0]=longest
        groups=balanced_ranks(global_indices,entries,world);local_indices=groups[rank]
        expected_tokens=sum(entries[i]['supervised_tokens'] for i in global_indices)
        denominator=len(global_indices)
        optimizer.zero_grad(set_to_none=True);loss_sum=0.0;response_tokens=0;step_start=time.monotonic()
        for index in local_indices:
            entry=entries[index];ids=torch.tensor(np.asarray(tokens[entry['offset']:entry['offset']+entry['length']],dtype=np.int64),device=device).unsqueeze(0)
            labels=ids.clone();labels[:,:entry['prefix_tokens']]=-100
            batch=TrainingBatch(ids,torch.ones_like(ids),labels,torch.tensor([entry['insert_at']],device=device))
            from torch.nn.attention import sdpa_kernel,SDPBackend
            with sdpa_kernel(SDPBackend.FLASH_ATTENTION):
                value,count=accumulate_response_loss(wrapper,batch,global_loss_denominator=denominator)
            if count!=entry['supervised_tokens']:raise ValueError('supervised tokens changed during model alignment')
            loss_sum+=value;response_tokens+=count
            del ids,labels,batch
        result=finish_prompt_update(wrapper,optimizer,local_loss_sum=loss_sum,local_response_tokens=response_tokens,local_loss_denominator=len(local_indices),learning_rate=cfg['learning_rate'],max_grad_norm=cfg['max_grad_norm'])
        if result.response_tokens!=expected_tokens:raise ValueError('global token denominator changed')
        # Both communication and optimizer state stay FP32; backbone remains frozen.
        if wrapper.prompt_parameter.dtype!=torch.float32 or wrapper.prompt_parameter.grad.dtype!=torch.float32:raise ValueError('SP precision changed')
        if any(p.grad is not None or p.requires_grad for p in student.parameters()):raise ValueError('backbone received gradients')
        event=dict(update=update,**asdict(result),effective_batch=64,loss_normalization='sequence',gradient_norm_after_clip=float(torch.linalg.vector_norm(wrapper.prompt_parameter.grad)),seconds=time.monotonic()-step_start,elapsed_seconds=time.monotonic()-began,global_batch_sha256=digest(global_indices),gpu_max_memory_bytes=torch.cuda.max_memory_allocated(device))
        if rank==0:
            with (run/'metrics.jsonl').open('a') as stream:stream.write(json.dumps(event)+'\n');stream.flush();os.fsync(stream.fileno())
            atomic_json(run/'progress.json',dict(status='TRAINING',**event));print(json.dumps(event),flush=True)
        flag=torch.tensor(int(stop[0]),device=device);dist.all_reduce(flag,op=dist.ReduceOp.MAX)
        save=smoke or update%20==0 or bool(flag.item())
        if save:
            states=gather_rank_states(capture_rank_state(rank=rank,data_cursor=dict(completed_update=update,next_update=update+1,shuffle_recipe=cfg['shuffle'],dataset_records=len(entries),global_batch_sha256=digest(global_indices),rank_indices=local_indices)))
            path=run/'checkpoints'/f'update-{update:04d}'
            if rank==0:
                receipt=save_checkpoint(path,prompt=wrapper.prompt_parameter,optimizer=optimizer,rank_states=states,update=update,hashes=identities,world_size=world,reason='predeadline' if smoke or update%20 else 'scheduled')
                checkpoint_copy(cfg if not smoke else dict(cfg,local_backup=cfg['local_backup']+'/smoke'),path)
            dist.barrier()
            if smoke:
                before=wrapper.prompt_parameter.detach().clone();state=optimizer.state_dict()
                restored=restore_checkpoint(path,prompt=wrapper.prompt_parameter,optimizer=optimizer,hashes=identities,rank=rank,world_size=world)
                if not torch.equal(before,wrapper.prompt_parameter) or restored['update']!=1:raise ValueError('real GPU full-state checkpoint restore changed prompt')
                adam=optimizer.state[wrapper.prompt_parameter]
                if not torch.equal(adam['exp_avg'],state['state'][0]['exp_avg']) or not torch.equal(adam['exp_avg_sq'],state['state'][0]['exp_avg_sq']):raise ValueError('optimizer restore changed moments')
                if rank==0:
                    atomic_json(BASE/'evidence/math-sp-freqinit-gpu-smoke-v1.json',dict(status='PASS_REAL_DP4_GLOBAL_BATCH64_LONGEST_RECORD_BACKWARD_FP32_ADAM_AND_RESUME',allocation=allocation,hashes=identities,checkpoint=str(path),checkpoint_sha256=sha256(path/'state.pt'),metric=event,longest_sequence_tokens=manifest['max_length'],all_ranks=4,versions=versions))
        if flag.item():
            if rank==0:atomic_json(run/'terminal.json',dict(status='STOPPED_AT_RECOVERABLE_UPDATE',update=update))
            break
    else:
        if rank==0:atomic_json(run/'terminal.json',dict(status='SMOKE_COMPLETE' if smoke else 'TRAINING_COMPLETE',update=updates,finished_at=time.time(),config_sha256=sha256(CONFIG),data_sha256=identities['data']))
    dist.barrier();dist.destroy_process_group()
    if lock:lock.close()

def main():
    parser=argparse.ArgumentParser();parser.add_argument('mode',choices=['smoke','train']);args=parser.parse_args()
    train(smoke=args.mode=='smoke')

if __name__=='__main__':main()