"""Offline batched LoRA description inference; resumable immutable shards, no label inputs."""
import argparse
from pathlib import Path
import sys
import time
from functools import lru_cache

PROJECT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(PROJECT))
import torch
from peft import PeftModel
from pallet.mask_model_training_data import read,write,jsonl,require,gpu_receipt,sha
from pallet.cluster_targets import digest
from pallet.pallet_description_data import ROOT,sources_current
from pallet.pallet_description_supervision import PROMPT
from pallet.pallet_description_output import decode_output
from pallet.pallet_description_vlm import load,image_for
from pallet.pallet_description_vlm_repair import RUN


@lru_cache(maxsize=1)
def formal_directory():
    from pallet.mask_quota_saved_extension import load_formal_evidence
    from pallet.pallet_description_data import FORMAL_SOURCE
    return load_formal_evidence(read(FORMAL_SOURCE))[0]


def inference_image(r):
    if 'image' in r and (ROOT/r['image']).exists():return image_for(r)
    from PIL import Image
    from pallet.mask_annotation_full_data import context
    return Image.open(formal_directory()/r['source']['image']).convert('RGB').crop(context(r['source']['bbox'],r['source']['size']))


@torch.inference_mode()
def batch_predict(model,processor,records):
    images=[inference_image(r) for r in records];texts=[]
    for image in images:
        messages=[dict(role='user',content=[dict(type='image',image=image),dict(type='text',text=PROMPT)])]
        texts.append(processor.apply_chat_template(messages,tokenize=False,add_generation_prompt=True,enable_thinking=False))
    data=processor(text=texts,images=images,return_tensors='pt',padding=True).to('cuda');start=time.perf_counter()
    ids=model.generate(**data,max_new_tokens=128,do_sample=False,pad_token_id=processor.tokenizer.pad_token_id)
    torch.cuda.synchronize();ms=(time.perf_counter()-start)*1000;raws=processor.tokenizer.batch_decode(ids[:,data['input_ids'].shape[1]:],skip_special_tokens=True)
    return [dict(target_key=r['target_key'],image_sha256=r['image_sha256'],**decode_output(raw),batch_ms=ms,batch_size=len(records),prompt_sha256=sha(PROMPT)) for r,raw in zip(records,raws)]


def infer(mode,route='m1'):
    out=ROOT/f'descriptions_{mode}.jsonl';require(not out.exists(),'Preserve previous description output')
    require(sources_current(),'Sources changed before description inference');gpu=gpu_receipt(route);torch.set_num_threads(4)
    complete=read(RUN/'training_complete.json');adapter=RUN/'full_pool/adapter';require(digest(adapter/'adapter_model.safetensors')==complete['adapter_sha256'],'Adapter changed')
    records=jsonl(ROOT/('private/training.jsonl' if mode=='existing' else 'private/release_selected.jsonl'))
    processor,base=load('qwen');model=PeftModel.from_pretrained(base,adapter).merge_and_unload().eval();model.config.use_cache=True;processor.tokenizer.padding_side='left'
    parser_sha=digest(PROJECT/'pallet/pallet_description_output.py')
    parts=ROOT/f'description_parts_{mode}';parts.mkdir(mode=0o700,exist_ok=True);started=time.monotonic();allpred=[]
    for offset in range(0,len(records),64):
        path=parts/f'part_{offset:06d}.json';group=records[offset:offset+64]
        if path.exists():
            part=read(path);require(part['targets']==[r['target_key'] for r in group] and part['adapter_sha256']==complete['adapter_sha256'] and part['code_sha256']==digest(__file__) and part['output_parser_sha256']==parser_sha,'Existing shard/model/implementation differs')
        else:
            preds=[]
            for j in range(0,len(group),16):preds.extend(batch_predict(model,processor,group[j:j+16]))
            for p in preds:p['adapter_sha256']=complete['adapter_sha256'];p['model']='Qwen/Qwen3.5-0.8B+round3-LoRA';p['status']='machine_draft'
            part=dict(targets=[r['target_key'] for r in group],predictions=preds,adapter_sha256=complete['adapter_sha256'],code_sha256=digest(__file__),output_parser_sha256=parser_sha)
            write(path,part)
        allpred.extend(part['predictions'])
        if offset%512==0:print(dict(mode=mode,inferred=len(allpred),total=len(records),seconds=round(time.monotonic()-started)),flush=True)
    require(sources_current(),'Source changed during description inference')
    write(out,allpred,lines=True)
    write(ROOT/f'description_inference_{mode}.json',dict(state='actual_batched_tiny_VLM_descriptions_complete',mode=mode,targets=len(allpred),schema_valid=sum(p['valid'] for p in allpred),
        actual_model_raw_retained=True,invalid_outputs_not_silently_fabricated=True,source_images_sha256=sha([(r['target_key'],r['image_sha256']) for r in records]),
        structure_only_recovered=sum(p['structure_recovered'] for p in allpred),observation_withheld=sum(p['observation_withheld'] for p in allpred),output_parser_sha256=parser_sha,
        adapter_sha256=complete['adapter_sha256'],gpu=gpu,seconds=time.monotonic()-started,predictions_sha256=digest(out),
        input_features='fixed_bbox_original_gray_pixels_and_constant_prompt_only_no_class_K_polygon_or_human_note',code_sha256=digest(__file__)))
    print(dict(state='description_inference_complete',mode=mode,targets=len(allpred),schema_valid=sum(p['valid'] for p in allpred)),flush=True)


if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('mode',choices=['new','existing']);p.add_argument('--route',choices=['m1','m2'],default='m1');a=p.parse_args();infer(a.mode,a.route)
