"""Pinned tiny VLM baseline/LoRA/inference. No class, keypoint or note is an input feature."""
import argparse
from collections import Counter
import importlib.metadata
import json
import math
from pathlib import Path
import random
import shutil
import time
import traceback

import torch
from PIL import Image
from transformers import AutoProcessor,AutoModelForImageTextToText

from .mask_model_training_data import PROJECT,read,write,jsonl,sha,require,gpu_receipt
from .cluster_targets import digest
from .pallet_description_data import ROOT,MODELS,FORMAL_SOURCE,sources_current
from .pallet_description_supervision import PROMPT,parse_prediction

RUN=ROOT/'vlm_run_v1'


def load(name):
    folder=MODELS/name;receipt=read(MODELS/(name+'_download.json'))
    for path,h in receipt['files'].items():require(digest(folder/path)==h,'Pinned VLM weight/config changed')
    processor=AutoProcessor.from_pretrained(folder,local_files_only=True)
    # Bound image-token budget; keep aspect ratio. This is grayscale sensor data, not natural RGB.
    if hasattr(processor.image_processor,'min_pixels'):processor.image_processor.min_pixels=128*128
    if hasattr(processor.image_processor,'max_pixels'):processor.image_processor.max_pixels=256*256
    if name=='smol':
        processor.image_processor.size={'longest_edge':512}
        processor.image_processor.do_image_splitting=False
    model=AutoModelForImageTextToText.from_pretrained(folder,dtype=torch.bfloat16,attn_implementation='sdpa',local_files_only=True).cuda()
    model.config.use_cache=True
    return processor,model


def image_for(r):
    if 'image' in r and (ROOT/r['image']).exists():return Image.open(ROOT/r['image']).convert('RGB')
    from .mask_quota_saved_extension import load_formal_evidence
    from .mask_annotation_full_data import context
    formal,_,_=load_formal_evidence(read(FORMAL_SOURCE));image=Image.open(formal/r['source']['image']).convert('RGB')
    return image.crop(context(r['source']['bbox'],r['source']['size']))


def inputs(processor,r,answer=None):
    image=image_for(r);messages=[dict(role='user',content=[dict(type='image',image=image),dict(type='text',text=PROMPT)])]
    if answer is not None:messages.append(dict(role='assistant',content=[dict(type='text',text=answer)]))
    text=processor.apply_chat_template(messages,tokenize=False,add_generation_prompt=answer is None,enable_thinking=False)
    data=processor(text=[text],images=[image],return_tensors='pt')
    return data.to('cuda')


@torch.inference_mode()
def predict(model,processor,r):
    data=inputs(processor,r);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();elapsed=(time.perf_counter()-start)*1000
    raw=processor.tokenizer.decode(ids[0,data['input_ids'].shape[1]:],skip_special_tokens=True)
    return dict(target_key=r['target_key'],**parse_prediction(raw),elapsed_ms=elapsed,input_ids=int(data['input_ids'].shape[1]),generated_tokens=int(ids.shape[1]-data['input_ids'].shape[1]))


def score(predictions,records):
    bykey={r['target_key']:r for r in records};correct=Counter();defined=Counter()
    for p in predictions:
        target=bykey[p['target_key']]['target']
        for key in ('支腿','横梁','材质'):
            defined[key]+=1;correct[key]+=int(p['valid'] and p['fields'].get(key)==target[key])
    return dict(targets=len(predictions),JSON_valid=sum(p['valid'] for p in predictions),attribute_accuracy={k:correct[k]/defined[k] for k in defined},
        latency_ms_mean=sum(p['elapsed_ms'] for p in predictions)/max(1,len(predictions)),peak_allocated_GiB=torch.cuda.max_memory_allocated()/2**30,
        observation_generalization_certified=False,observation_labeled_examples=sum(r['observation_supervised'] for r in records))


def baseline(name):
    require(not (RUN/(name+'_baseline.json')).exists(),'Preserve previous baseline');RUN.mkdir(mode=0o700,exist_ok=True)
    gpu=gpu_receipt('m1');torch.set_num_threads(4);random.seed(42);torch.manual_seed(42)
    records=jsonl(ROOT/'description_data/pilot.jsonl');held=[r for r in records if r['split']=='holdout']
    chosen=[]
    for cls in sorted({r['class_id'] for r in held}):chosen.extend([r for r in held if r['class_id']==cls][:1])
    processor,model=load(name);predictions=[predict(model,processor,r) for r in chosen]
    write(RUN/(name+'_baseline_predictions.jsonl'),predictions,lines=True)
    write(RUN/(name+'_baseline.json'),dict(model=name,gpu=gpu,**score(predictions,chosen),repo=read(MODELS/(name+'_download.json')),torch=torch.__version__,transformers=importlib.metadata.version('transformers')))
    print(dict(phase='baseline',model=name,**score(predictions,chosen)),flush=True)


def train_phase(name,records,epochs=2):
    from peft import LoraConfig,get_peft_model
    folder=RUN/name;require(not folder.exists(),'Use a fresh LoRA attempt');folder.mkdir(mode=0o700)
    processor,base=load('qwen')
    targets=[n for n,m in base.named_modules() if isinstance(m,torch.nn.Linear) and ('language_model' in n or 'text_model' in n) and n.endswith(('q_proj','k_proj','v_proj','o_proj','in_proj_qkv','out_proj','gate_proj','up_proj','down_proj'))]
    require(targets,'No supported text linear modules found for LoRA')
    model=get_peft_model(base,LoraConfig(r=8,lora_alpha=16,lora_dropout=.05,target_modules=targets,bias='none',task_type='CAUSAL_LM'))
    model.config.use_cache=False;model.gradient_checkpointing_enable();model.enable_input_require_grads()
    params=[p for p in model.parameters() if p.requires_grad];require(params,'No trainable parameters')
    optimizer=torch.optim.AdamW(params,lr=1e-4,weight_decay=.01);step=0;history=[];start=time.monotonic();accum=8
    write(folder/'execution_plan.json',dict(epochs=epochs,records=len(records),LoRA_rank=8,trainable_parameters=sum(p.numel() for p in params),
        total_parameters=sum(p.numel() for p in model.parameters()),frozen_vision=True,masked_missing_observations=True,targets=targets,
        dataset_sha256=digest(ROOT/'description_data/manifest.json'),seed=42,lr=1e-4,accumulation=accum,
        source_model=read(MODELS/'qwen_download.json'),source_code_sha256=digest(__file__)))
    for epoch in range(epochs):
        order=list(records);random.Random(42+epoch).shuffle(order);model.train();optimizer.zero_grad();loss_sum=0
        for i,r in enumerate(order):
            answer=json.dumps(r['target'],ensure_ascii=False,separators=(',',':'))
            full=inputs(processor,r,answer);prompt=inputs(processor,r);start_token=prompt['input_ids'].shape[1]
            labels=full['input_ids'].clone();labels[:,:start_token]=-100
            if not r['observation_supervised']:
                # Never train absent notes as "no anomaly" (or as a per-image unknown assertion).
                prefix=answer[:answer.index(',"观察"')]
                token_count=len(processor.tokenizer.encode(prefix,add_special_tokens=False))
                labels[:,start_token+max(0,token_count-1):]=-100
            require((labels!=-100).any(),'All labels masked')
            loss=model(**full,labels=labels).loss;require(torch.isfinite(loss).item(),'Nonfinite VLM loss');loss_sum+=float(loss.detach())
            (loss/accum).backward()
            if (i+1)%accum==0 or i+1==len(order):
                norm=torch.nn.utils.clip_grad_norm_(params,1.);require(torch.isfinite(norm).item(),'Nonfinite LoRA gradient');optimizer.step();optimizer.zero_grad();step+=1
            if (i+1)%100==0:print(dict(phase=name,epoch=epoch+1,samples=i+1,total=len(order),steps=step,seconds=round(time.monotonic()-start)),flush=True)
        entry=dict(epoch=epoch+1,steps=step,samples=len(order),mean_loss=loss_sum/len(order),exposure_sha256=sha([r['target_key'] for r in order]),seconds=time.monotonic()-start)
        write(folder/f'epoch_{epoch+1:03d}.json',entry);history.append(entry)
    model.save_pretrained(folder/'adapter');processor.save_pretrained(folder/'adapter');model.eval();model.config.use_cache=True
    write(folder/'training_receipt.json',dict(optimizer_steps=step,epochs=epochs,records=len(records),history_sha256=sha(history),seconds=time.monotonic()-start,
        adapter_sha256=digest(folder/'adapter/adapter_model.safetensors'),vision_frozen=True,source_code_sha256=digest(__file__)))
    return model,processor


def train():
    require(not (RUN/'training_complete.json').exists(),'Keep previous VLM training evidence');gpu=gpu_receipt('m1');torch.set_num_threads(4);random.seed(42);torch.manual_seed(42)
    RUN.mkdir(mode=0o700,exist_ok=True);records=jsonl(ROOT/'description_data/pilot.jsonl');subset=[r for r in records if r['split']=='train'];held=[r for r in records if r['split']=='holdout']
    model,processor=train_phase('component_branch',subset)
    predictions=[predict(model,processor,r) for r in held]
    write(RUN/'component_branch/holdout_predictions.jsonl',predictions,lines=True);write(RUN/'component_branch/holdout_metrics.json',dict(scope='component_holdout_weak_class_definition_supervision_not_new_blind_test',**score(predictions,held)))
    del model,processor;import gc;gc.collect();torch.cuda.empty_cache()
    # Fresh same pretrained base; never warm-start the "independent" branch from the full pool.
    model,processor=train_phase('full_pool',records)
    require(sources_current(),'Source changed during VLM training')
    write(RUN/'training_complete.json',dict(state='actual_tiny_VLM_LoRA_complete',gpu=gpu,model='Qwen3.5-0.8B',
        adapter_sha256=digest(RUN/'full_pool/adapter/adapter_model.safetensors'),component_metrics_sha256=digest(RUN/'component_branch/holdout_metrics.json'),
        training_scope='bounded_component_and_class_balanced_pilot_not_all5615',code_sha256=digest(__file__)))
    print(dict(state='actual_tiny_VLM_LoRA_complete'),flush=True)


if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('phase',choices=['baseline','train']);p.add_argument('--model',default='qwen');a=p.parse_args()
    try:(baseline(a.model) if a.phase=='baseline' else train())
    except Exception:
        RUN.mkdir(mode=0o700,exist_ok=True);name=RUN/(a.phase+'_'+a.model+'_failure_'+str(time.time_ns())+'.json');write(name,dict(traceback=traceback.format_exc()));raise
