"""Round3 frozen human geometry + partial description supervision; no source writers."""
from collections import Counter,defaultdict
from contextlib import closing
from copy import deepcopy
import hashlib
import json
import shutil

import cv2
import numpy as np

from .cluster_targets import digest
from .mask_model_training_data import PROJECT,FALSE_FLAGS,read,write,jsonl,sha,require
from . import mask_taxonomy_cycle2_data as prior
from . import mask_taxonomy_data as first
from .mask_class_note_integration import snapshot_db
from .mask_template_refined import readonly
from .mask_quality_recovery import POSE,fingerprint
from .mask_annotation_full_data import context,supervision_valid
from .mask_quality_override import human_protection
from .mask_quota_saved_extension import load_formal_evidence
from .pose_review_geometry import polygon_value,raster_mask

ROOT=PROJECT/'outputs/pallet_description_round3_training_v1'
MODELS=PROJECT/'outputs/pallet_description_vlm_models_v1'
FORMAL_SOURCE=prior.FORMAL_SOURCE
AUTHORIZATION='已经完成48+22复核；三项均可修订；当前GPU服务器；执行'


def binding_guard():
    # New output prefix does not enter the frozen previous epochs' inventories.
    module=prior.engine('pallet/mask_taxonomy_cycle2_data.py','round3_guard')
    module.ROOT=ROOT;module.REQUESTS=ROOT/'unpublished_requests';module.REVIEWS=ROOT/'unpublished_reviews'
    return module.source_guard()


def sources_current():
    g=binding_guard()
    try:return g.current()
    finally:g.close()


def accept_batch(props,reviews,classes,binding):
    result=[]
    require(set(reviews)<=set(props),'Unknown saved target')
    for key,p in props.items():
        v=reviews.get(key);cls=v['class_id'] if v else p['class_id'];poly=v['polygon'] if v else p['polygon'];info=classes[str(cls)]
        require(info['train_enabled'],'Unresolved class cannot enter standard training')
        if v:
            require(v['target_key']==key and v['source_binding']==sha(p) and v['binding']==binding and v['source']==p['source']
                and v['base_proposal_id']==sha(p) and v['checkpoint_sha256']==p['checkpoint_sha256'],'Review/source binding mismatch')
            require(v['action'] in ('correct','draft'),'Deferred targets need separate authorization')
        polygon_value(poly,*p['source']['size']);require(len(poly)==info['K'],'Accepted fine-class K mismatch')
        result.append(dict(target_key=key,class_id=cls,K=info['K'],polygon=deepcopy(poly),source=p['source'],image_sha256=p['image_sha256'],
            source_revision=v['revision'] if v else None,source_payload_sha256=sha(v or p),original_review_action=v['action'] if v else 'never_saved',
            geometry_source='latest_saved_human_correct' if v and v['action']=='correct' else 'explicit_batch_confirmed_latest_draft' if v else 'explicit_batch_confirmed_unchanged_proposal',
            batch_authorization=None if v and v['action']=='correct' else AUTHORIZATION,note=v.get('note','') if v else '',prior_proposal_sha256=sha(p),**FALSE_FLAGS))
    return result


def prepare():
    require(not ROOT.exists(),'Fresh round3 dataset required');require(shutil.disk_usage(PROJECT/'outputs').free>40*2**30,'Disk reserve required')
    _,base=prior.verify();require(prior.sources_current(),'Prior source changed')
    _,_,revision,_,_,_,_,_=first.source_state();require(revision==5,'Changed class graph requires new mapping audit')
    classes=read(prior.ROOT/'classes.json');parents=read(prior.ROOT/'parents.json');props={p['target_key']:p for p in jsonl(prior.REQUESTS/'proposals.jsonl')}
    ROOT.mkdir(mode=0o700);(ROOT/'private').mkdir(mode=0o700)
    snapshot_db(prior.REVIEWS/'mask_reviews.sqlite3',ROOT/'private/cycle2_reviews.sqlite3')
    with closing(readonly(ROOT/'private/cycle2_reviews.sqlite3')) as db:
        db.execute('BEGIN');reviews={k:json.loads(v) for k,v in db.execute('SELECT target_key,payload FROM reviews')}
        events=list(db.execute('SELECT id,target_key,revision,payload FROM events ORDER BY id'));meta=dict(db.execute('SELECT key,value FROM metadata'))
    binding=digest(prior.REQUESTS/'manifest.json');require(meta['namespace']==prior.NAMESPACE and meta['formal_manifest_sha256']==binding,'Wrong source snapshot')
    latest={k:(rev,raw) for _,k,rev,raw in events};require(set(latest)==set(reviews) and all(json.loads(raw)==reviews[k] and reviews[k]['revision']==rev for k,(rev,raw) in latest.items()),'History/current disagreement')
    accepted=accept_batch(props,reviews,classes,binding);require(len(accepted)==1588 and not {r['target_key'] for r in base}&set(props),'Repeated or missing targets')
    classes=prior.update_classes(classes,base+accepted);write(ROOT/'classes.json',classes);write(ROOT/'parents.json',parents)
    write(ROOT/'private/accepted_cycle2.jsonl',accepted,lines=True)
    write(ROOT/'research_permit.json',dict(user_authorization=AUTHORIZATION,original_48_unsaved_22_draft_confirmed=True,
        actual_snapshot_actions=dict(Counter(v['action'] for v in reviews.values())),actual_unsaved=len(set(props)-set(reviews)),source_events_never_rewritten=True,
        category_keypoints_and_descriptions_separate_review_states=True,**FALSE_FLAGS))
    formal,rows,evidence=load_formal_evidence(read(FORMAL_SOURCE));hashes=read(prior.ROOT/'private/image_hashes.json');components=read(prior.ROOT/'private/components.json')
    for name in ('private/image_hashes.json','private/components.json'):shutil.copyfile(prior.ROOT/name,ROOT/name)
    for image,h in hashes.items():require(digest(formal/image)==h,'Original image changed')
    neighbors=defaultdict(list)
    for r in rows.values():neighbors[r['frame_id']].append(r)
    for name in ('images','masks','valid'):(ROOT/'private'/name).mkdir(mode=0o700)
    training=[];cv2.setNumThreads(1)
    for r in base:
        v=deepcopy(r);v['small_sample']=classes[str(r['class_id'])]['small_sample'];v['training_origin']='previous_4027_confirmed'
        for name in ('image','mask','valid'):shutil.copyfile(prior.ROOT/r[name],ROOT/r[name])
        training.append(v)
    for r in accepted:
        key=r['target_key'];row=rows[key];info=classes[str(r['class_id'])];require(row==r['source'] and hashes[row['image']]==r['image_sha256'],'Source row mismatch')
        roi=context(row['bbox'],row['size']);x1,y1,x2,y2=roi;full=raster_mask(r['polygon'],*row['size']).astype(np.uint8);mask=full[y1:y2,x1:x2]
        require(mask.any() and full.sum()==mask.sum(),'Fixed ROI clips human supervision')
        valid=supervision_valid(roi,neighbors[row['frame_id']],key,mask);image=evidence.image(row['frame_id'])[y1:y2,x1:x2]
        for name,array in (('images',image),('masks',mask*255),('valid',valid*255)):require(cv2.imwrite(str(ROOT/'private'/name/f'{key}.png'),array),'Export failed')
        training.append(dict(**r,fine_index=info['fine_index'],parent=info['parent'],parent_index=info['parent_index'],small_sample=info['small_sample'],component=components['by_target'][key],
            roi=roi,image=f'private/images/{key}.png',mask=f'private/masks/{key}.png',valid=f'private/valid/{key}.png',training_origin='round2_confirmed'))
    split=first.split_components(training)
    for r in training:r['evaluation_branch_split']=split[r['target_key']]
    require(len(training)==5615,'Unexpected current training count');write(ROOT/'private/training.jsonl',training,lines=True)
    protected,pose,stores,reasons=human_protection(rows,training)
    stores.update({name:fingerprint(PROJECT/name) for name in prior.database_inventory()});stores[str(POSE.relative_to(PROJECT))]=fingerprint(POSE)
    stores[str((prior.REVIEWS/'mask_reviews.sqlite3').relative_to(PROJECT))]=fingerprint(prior.REVIEWS/'mask_reviews.sqlite3')
    require(fingerprint(prior.REVIEWS/'mask_reviews.sqlite3')==fingerprint(ROOT/'private/cycle2_reviews.sqlite3'),'Concurrent source edit')
    inventories={name:digest(PROJECT/name) for name in prior.worklist_inventory()}
    # cycle2 discover excludes itself; explicitly include it as a source in round3.
    inventories[str((prior.REQUESTS/'proposals.jsonl').relative_to(PROJECT))]=digest(prior.REQUESTS/'proposals.jsonl')
    for name in inventories:
        for r in jsonl(PROJECT/name):
            if r.get('target_key') in rows:protected.add(r['target_key'])
    blocked={hashes[rows[k]['image']] for k in protected if k in rows};candidates=[]
    for r in jsonl(prior.ROOT/'private/candidates.jsonl'):
        if r['target_key'] in protected or r['image_sha256'] in blocked:continue
        candidates.append(r)
    write(ROOT/'private/candidates.jsonl',candidates,lines=True)
    write(ROOT/'private/protection.json',dict(inventories=inventories,protected_image_hashes=sorted(blocked),protected_targets=sorted(protected),human_reasons=reasons))
    files=dict(read(prior.ROOT/'source_binding.json')['file_hashes']);files.update(inventories)
    for p in (prior.ROOT/'dataset_manifest.json',prior.ROOT/'private/training.jsonl',prior.REQUESTS/'manifest.json',prior.REQUESTS/'classes.json'):
        files[str(p.relative_to(PROJECT))]=digest(p)
    write(ROOT/'source_binding.json',dict(class_graph_revision=revision,database_fingerprints=stores,file_hashes=files,cycle2_events=len(events),source_snapshot_sha256=digest(ROOT/'private/cycle2_reviews.sqlite3')))
    report=dict(state='round3_frozen_current_human_data',training_targets=len(training),unique_images=len({r['image_sha256'] for r in training}),new_snapshot_actions=dict(Counter(r['original_review_action'] for r in accepted)),
        actual_notes=sum(bool(r['note'].strip()) for r in accepted),fine_classes=41,parents=9,small_classes=[c['class_id'] for c in classes.values() if c['train_enabled'] and c['small_sample']],
        candidates=len(candidates),candidate_images=len({r['image_sha256'] for r in candidates}),splits=dict(Counter(r['evaluation_branch_split'] for r in training)),**FALSE_FLAGS)
    write(ROOT/'preparation_report.json',report)
    write(ROOT/'dataset_manifest.json',dict(schema='pallet-round3-human5615-v1',records=len(training),files={str(p.relative_to(ROOT)):digest(p) for p in ROOT.rglob('*') if p.is_file()},code_sha256=digest(__file__)))
    verify();require(sources_current(),'Source inventory changed');print(report,flush=True)


def verify():
    m=read(ROOT/'dataset_manifest.json')
    for name,h in m['files'].items():require(digest(ROOT/name)==h,'Frozen dataset changed: '+name)
    records=jsonl(ROOT/'private/training.jsonl');classes=read(ROOT/'classes.json');groups=defaultdict(set);images=defaultdict(set)
    require(len(records)==len({r['target_key'] for r in records})==5615,'Unique5615 supervision targets required')
    for r in records:
        c=classes[str(r['class_id'])];require(c['train_enabled'] and len(r['polygon'])==r['K']==c['K'] and r['parent']==c['parent'],'Fine class/K/parent mismatch')
        groups[r['evaluation_branch_split']].add(r['component']);images[r['evaluation_branch_split']].add(r['image_sha256'])
    require(not groups['train']&groups['holdout'] and not images['train']&images['holdout'],'Component leakage')
    return m,records
