"""Independent new-image and existing-human task bundles with description drafts."""
import csv
from collections import Counter
import json
import shutil

from PIL import Image

from .cluster_targets import digest
from .mask_model_training_data import PROJECT,FALSE_FLAGS,read,write,jsonl,sha,require
from .mask_taxonomy_review import draw_case
from .mask_quota_saved_extension import load_formal_evidence
from .pallet_description_data import ROOT,FORMAL_SOURCE,verify,sources_current
from .pallet_description_mask import RUN
from .pallet_description_vlm_repair import RUN as VLM_RUN
from .pallet_description_review import SETS,validate_description
from .pallet_description_ui import assets


def description_draft(pred):
    fields=pred.get('fields') if pred.get('valid') else pred.get('recovered_fields')
    if not fields:return dict(text='无法判断：模型结构输出未通过，需人工填写。',legs=None,beams=None,material='无法判断',observation='无法判断：模型输出未通过，需人工填写。',observation_state='unreviewed')
    text=fields['结构'].strip() or '无法判断托盘结构'
    observation=fields.get('观察') or ('无法判断：模型观察格式失败，需人工填写；原始输出和人工原备注仅供对照。' if pred.get('observation_withheld') else '无法判断')
    return dict(text=text,legs=fields['支腿'],beams=fields['横梁'],material=fields['材质'],observation=observation,observation_state='unreviewed')


def build(mode):
    settings=SETS[mode];out=settings['root'];require(not out.exists(),'Preserve previous task bundle');require(sources_current(),'Source changed before bundle build')
    _,training=verify();classes=read(ROOT/'classes.json');formal,rows,_=load_formal_evidence(read(FORMAL_SOURCE));out.mkdir(mode=0o700)
    for folder in ('cases','examples'):(out/folder).mkdir()
    inference=read(ROOT/'inference_complete.json');mask_sha=digest(RUN/'full_pool/final_ema.pt')
    descriptions={r['target_key']:r for r in jsonl(ROOT/f'descriptions_{mode}.jsonl')};vlm_complete=read(VLM_RUN/'training_complete.json');vlm_sha=vlm_complete['adapter_sha256']
    if mode=='new':selected=jsonl(ROOT/'private/release_selected.jsonl')
    else:selected=[dict(**r,classified_class_id=r['class_id']) for r in training]
    examples={}
    for info in classes.values():
        if not info['train_enabled']:continue
        members=[r for r in training if r['class_id']==info['class_id']];chosen=[]
        for r in members:
            if len(chosen)==2:break
            if not chosen or r['component']!=chosen[0]['component']:chosen.append(r)
        if len(chosen)<2:chosen=members[:2]
        examples[str(info['class_id'])]=[]
        for i,r in enumerate(chosen):
            path=f'examples/class{info["class_id"]}_{i}.png';image=Image.open(formal/r['source']['image']).convert('RGB');draw_case(image,r['polygon'],r['roi']).save(out/path)
            examples[str(info['class_id'])].append(dict(path=path,target_key=r['target_key'],K=info['K'],source_polygon_sha256=sha(r['polygon']),source_human_revision=r['source_revision']))
    proposals=[];images={};prior_notes={r['target_key']:r.get('note','') for r in jsonl(ROOT/'private/accepted_cycle2.jsonl')}
    for r in selected:
        key=r['target_key'];info=classes[str(r['classified_class_id'])];row=r['source'];pred=descriptions[key]
        require(pred['image_sha256']==r['image_sha256'] and pred['adapter_sha256']==vlm_sha,'Description inference image/model differs')
        require(len(r['polygon'])==info['K'],'Initial strictK mismatch')
        image=Image.open(formal/row['image']).convert('RGB');draw_case(image,r['polygon'],r['roi']).save(out/'cases'/f'{key}.png');images[f'images/{key}.png']=dict(formal_relative_image=row['image'],sha256=r['image_sha256'])
        classification=({k:r[k] for k in ('fine_candidates','fine_confidence','fine_top2_margin','parent_confidence','prototype_class_id','prototype_cosine')} if mode=='new' else dict(fine_candidates=[],fine_confidence=0.,fine_top2_margin=0.,parent_confidence=0.,prototype_class_id=None,prototype_cosine=0.,source='previously_human_completed_not_machine_confidence'))
        d=description_draft(pred);validate_description(d)
        proposals.append(dict(schema=settings['namespace'],target_key=key,class_id=info['class_id'],K=info['K'],parent=info['parent'],polygon=r['polygon'],source=row,roi=r['roi'],
            image_sha256=r['image_sha256'],pose_payload_raw_sha256=r.get('pose_payload_raw_sha256'),classification=classification,class_graph_revision=5,
            geometry_provenance=r.get('conversion') if mode=='new' else dict(kind='previous_confirmed_exact_polygon',source_revision=r['source_revision'],source_payload_sha256=r['source_payload_sha256']),
            checkpoint_sha256=mask_sha,original_formal_class_id=row['final_class_id'],geometry_previously_completed=mode=='existing',
            initial_geometry_status='human_completed' if mode=='existing' else 'machine_draft',description=d,description_raw=pred['raw'],description_parse_valid=pred['valid'],
            description_structure_recovered=pred.get('structure_recovered',False),description_observation_withheld=pred.get('observation_withheld',False),
            description_model_sha256=vlm_sha,description_initial_status='machine_draft',human_note=prior_notes.get(key,''),
            template_used=False,quality_override_used=False,propagation_seed_eligible=False,**FALSE_FLAGS))
    write(out/'proposals.jsonl',proposals,lines=True);write(out/'classes.json',classes);write(out/'examples.json',examples)
    if mode=='new':quotas=read(ROOT/'release_quota_report.json')
    else:quotas={str(c['class_id']):dict(class_id=c['class_id'],K=c['K'],parent=c['parent'],selected_new_images=sum(r['class_id']==c['class_id'] for r in training),gap=0,counts_are_existing_targets_not_new_image_quota=True) for c in classes.values() if c['train_enabled']}
    write(out/'quota_report.json',quotas)
    write(out/'summary.json',dict(mode=mode,targets=len(proposals),requested_images=4100 if mode=='new' else len(proposals),gap=4100-len(proposals) if mode=='new' else 0,
        candidate_targets=inference['candidate_targets'],unresolved_classification_targets=inference['candidate_targets']-inference['classification_pass_targets'],
        independent_metrics=read(RUN/'independent_branch/holdout_metrics.json'),vlm_metrics=read(VLM_RUN/'component_branch/holdout_metrics.json'),
        vlm_structure_recovery_audit=read(VLM_RUN/'structure_recovery_audit.json'),
        description_inference=read(ROOT/f'description_inference_{mode}.json'),vlm_generalization_NOT_certified=True,all_model_descriptions_require_human_review=True))
    allpred=jsonl(ROOT/'private/predictions.jsonl');unresolved=[p for p in allpred if not p['classification_gate_passed']]
    write(out/'unresolved_examples.json',[{k:p[k] for k in ('target_key','candidate_class_id','fine_candidates','classification_withheld_reasons')} for p in unresolved[:100]])
    with (out/'classification.csv').open('x',encoding='utf-8-sig',newline='') as f:
        fields=['target_key','fine_candidate','accepted_class','K','actual_K','fine_score_uncalibrated','geometry_pass','classification_withheld','geometry_withheld','in_new_review_queue']
        writer=csv.DictWriter(f,fieldnames=fields);writer.writeheader();keys={p['target_key'] for p in proposals}
        for p in allpred:writer.writerow(dict(target_key=p['target_key'],fine_candidate=p['candidate_class_id'],accepted_class=p['classified_class_id'],K=p['requested_K'],actual_K=p['actual_K'],fine_score_uncalibrated=p['fine_confidence'],geometry_pass=p['geometry_gate_passed'],classification_withheld=';'.join(p['classification_withheld_reasons']),geometry_withheld=';'.join(p['geometry_withheld_reasons']),in_new_review_queue=p['target_key'] in keys if mode=='new' else False))
    write(out/'description_drafts.jsonl',[dict(target_key=p['target_key'],class_id=p['class_id'],description=p['description'],model_raw=p['description_raw'],strict_parse_valid=p['description_parse_valid'],structure_recovered=p['description_structure_recovered'],observation_withheld=p['description_observation_withheld'],description_status='machine_draft',geometry_status=p['initial_geometry_status']) for p in proposals],lines=True)
    for name,text in assets(mode).items():(out/name).write_text(text)
    from scripts.build_mask_remaining_direct_requests import build_font
    glyph_text=json.dumps([dict(description=p['description'],raw=p['description_raw'],note=p['human_note']) for p in proposals],ensure_ascii=False)
    build_font(out,(out/'page.html').read_text()+(out/'review.js').read_text()+json.dumps(classes,ensure_ascii=False)+glyph_text)
    m=dict(schema=settings['namespace'],mode=mode,request_count=len(proposals),proposals_sha256=digest(out/'proposals.jsonl'),original_images=images,
        public_assets={str(p.relative_to(out)):digest(p) for p in out.rglob('*') if p.is_file() and p.name!='proposals.jsonl'},
        dataset_manifest_sha256=digest(ROOT/'dataset_manifest.json'),source_binding_sha256=digest(ROOT/'source_binding.json'),mask_checkpoint_sha256=mask_sha,
        vlm_adapter_sha256=vlm_sha,description_predictions_sha256=digest(ROOT/f'descriptions_{mode}.jsonl'),code_sha256=digest(__file__),**FALSE_FLAGS)
    write(out/'manifest.json',m);print(dict(state='joint_bundle_built_pending_verification',mode=mode,targets=len(proposals)),flush=True)
