"""Code-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]
CONFIG=BASE/'configs/code-sp-training-v1.json'

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():
    cfg=read(CONFIG)
    for key in ('data_manifest','scientific_contract','student_readiness'):
        if sha256(cfg[key])!=cfg[key+'_sha256']: raise ValueError(key+' changed')
    auth=cfg['authorization']
    if not auth['data_manifest_accepted'] or sha256(auth['delivery_path'])!=auth['delivery_sha256']:
        raise ValueError('Code data authorization binding changed')
    contract=read(cfg['scientific_contract'])['our_experiment']
    for key,old in [('prompt_length','sp_length_each'),('updates','updates'),('effective_batch','effective_batch'),('checkpoint_every','checkpoint_every'),('learning_rate','learning_rate'),('seed','seed')]:
        if cfg[key]!=contract[old]: raise ValueError('scientific training contract changed: '+key)
    if cfg['model_path']!=read(cfg['student_readiness'])['model']['path']:raise ValueError('student path differs from pinned readiness')
    return cfg

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 prepare():
    allocation=require_allocation(); cfg=config()
    from transformers import AutoTokenizer
    tokenizer=AutoTokenizer.from_pretrained(cfg['model_path'],local_files_only=True)
    header,close=system_scaffold(tokenizer)
    manifest=read(cfg['data_manifest']); directory=Path(cfg['output'])/'data';directory.mkdir(parents=True,exist_ok=True)
    with (directory/'.prepare.lock').open('w') as lock:
        fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
        if (directory/'manifest.json').exists():
            validate_data(cfg); return read(directory/'manifest.json')
        entries=[]; position=0; seen=set(); counts={'existing_system':0,'added_empty_system':0}
        with (directory/'tokens.uint32.tmp').open('wb') as stream:
            for source in manifest['candidate_files']:
                if sha256(source['path'])!=source['sha256']:raise ValueError('candidate file changed')
                count=0
                with open(source['path']) as rows:
                    for line in rows:
                        row=json.loads(line); prefix=row['prefix_tokens']; original=row['input_ids'];labels=row['labels']
                        if row['request_id'] in seen or labels!=[-100]*prefix+original[prefix:]:raise ValueError('candidate identity/mask mismatch')
                        if not original[prefix:] or row['supervised_tokens']!=len(original)-prefix or original[-1] not in (151645,151643):raise ValueError('incomplete or empty candidate supervision')
                        seen.add(row['request_id'])
                        ids,prefix,insert,added=add_system(original,prefix,header,close)
                        if len(ids)+256>65534:raise ValueError('whole training sequence exceeds context')
                        counts['added_empty_system' if added else 'existing_system']+=1
                        values=array.array('I',ids)
                        if sys.byteorder!='little':values.byteswap()
                        stream.write(values.tobytes())
                        entries.append(dict(request_id=row['request_id'],question_id=row['question_id'],sample_index=row['sample_index'],offset=position,length=len(ids),prefix_tokens=prefix,supervised_tokens=len(ids)-prefix,insert_at=insert,source_response_sha256=row['response_sha256']))
                        position+=len(ids);count+=1
                if count!=source['count']:raise ValueError('candidate count changed')
            stream.flush();os.fsync(stream.fileno())
        if len(entries)!=cfg['candidate_answers'] or len(entries)!=manifest['candidate_answers']:raise ValueError('unexpected Code data count')
        (directory/'tokens.uint32.tmp').replace(directory/'tokens.uint32')
        atomic_json(directory/'index.json',entries)
        result=dict(schema='m2rl-code-sp-packed-data-v1',status='PASS_EXACT_SOURCE_TOKENS_RESPONSE_MASKS_AND_SYSTEM_PLACEMENT',allocation=allocation,config_sha256=sha256(CONFIG),source_manifest_sha256=sha256(cfg['data_manifest']),records=len(entries),tokens=position,max_length=max(e['length']+256 for e in entries),system_header_ids=header,system_close_ids=close,system_counts=counts,tokens_sha256=sha256(directory/'tokens.uint32'),index_sha256=sha256(directory/'index.json'),source_files=manifest['candidate_files'],producer_sha256=sha256(__file__))
        atomic_json(directory/'manifest.json',result)
        backup=Path(cfg['local_backup'])/'data';backup.mkdir(parents=True,exist_ok=True)
        files={}
        for name in ('tokens.uint32','index.json','manifest.json'):
            shutil.copy2(directory/name,backup/name)
            if sha256(directory/name)!=sha256(backup/name):raise ValueError('packed data backup mismatch')
            files[name]=sha256(backup/name)
        atomic_json(backup/'receipt.json',dict(status='PASS_LOCAL_DATA_COPY_RESTORED_SHA256',files=files))
        atomic_json(BASE/'evidence/code-sp-training-admission-v1.json',dict(status='CODE_DATA_ACCEPTED_TRAINING_AUTHORIZED_GPU_SMOKE_PENDING',authorization=cfg['authorization'],allocation=allocation,config_path=str(CONFIG),config_sha256=sha256(CONFIG),packed_data_path=str(directory/'manifest.json'),packed_data_sha256=sha256(directory/'manifest.json'),candidate_answers=len(entries),baseline_scores_preserved=True,initialization=cfg['prompt_initialization'],system_insertion=cfg['system_insertion']))
    print(json.dumps(result),flush=True);return result

def validate_data(cfg):
    directory=Path(cfg['output'])/'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/code-sp-gpu-training-smoke-v1.json')
        evaluation_proof=read(BASE/'evidence/code-sp-gpu-evaluation-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')
        if evaluation_proof['config_sha256']!=sha256(CONFIG) or evaluation_proof['producer_sha256']!=sha256(BASE/'scripts/code_sp_eval_v1.py'):raise ValueError('GPU SP evaluation adapter is not validated')
    import numpy as np
    import torch
    import torch.distributed as dist
    from transformers import AutoModelForCausalLM
    from soft_prompt_distillation.training import SoftPromptModel,TrainingBatch,batch_indices_for_update,accumulate_response_loss,finish_prompt_update
    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)
    generator=torch.Generator(device=device).manual_seed(seed)
    prompt=torch.randn((256,student.config.hidden_size),dtype=torch.float32,device=device,generator=generator)*cfg['prompt_initialization']['std']
    wrapper=SoftPromptModel(student,prompt,activation_checkpointing=True,cross_entropy_backend='liger_fused',loss_normalization='token')
    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]
        denominator=sum(entries[i]['supervised_tokens'] for i in 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=response_tokens,learning_rate=cfg['learning_rate'],max_grad_norm=None)
        if result.response_tokens!=denominator: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,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/code-sp-gpu-training-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=['prepare','smoke','train']);args=parser.parse_args()
    if args.mode=='prepare':prepare()
    else:train(smoke=args.mode=='smoke')

if __name__=='__main__':main()