"""Independent fine-class review with true new-image quotas and append-only edits."""
from collections import Counter
from contextlib import closing
import csv
import hashlib
import hmac
import io
import json
from pathlib import Path
import re
import shutil

from PIL import Image, ImageDraw

from .cluster_targets import digest
from .mask_gallery import Handler
from .mask_gallery_review import MaskReviewStore, ReviewError
from .mask_model_training_data import PROJECT, FALSE_FLAGS, jsonl, read, require, sha, write
from .mask_quota_saved_extension import load_formal_evidence
from .mask_taxonomy_data import ROOT, REQUESTS, REVIEWS, NAMESPACE, FORMAL_SOURCE, sources_current, verify
from .mask_taxonomy_train import RUN
from .pose_review_geometry import canonical, polygon_value, raster_mask

ASSETS = PROJECT/'pallet/assets/mask_taxonomy'


def draw_case(image,polygon,roi):
    x1,y1,x2,y2=roi;crop=image.crop((x1,y1,x2,y2)).convert('RGB');draw=ImageDraw.Draw(crop)
    points=[(x-x1,y-y1) for x,y in polygon];draw.line(points+[points[0]],fill='#37e1e8',width=1)
    for i,(x,y) in enumerate(points,1):
        draw.ellipse((x-1,y-1,x+1,y+1),fill='#ffc459');draw.text((x+2,y+1),str(i),fill='#ffc459')
    return crop


def build():
    require(not REQUESTS.exists(),'Preserve published task version; use a new directory')
    require(sources_current(),'Source changed; cannot publish stale classification/K')
    verify(); result=read(ROOT/'inference_complete.json');selected=jsonl(ROOT/'private/release_selected.jsonl')
    release=read(ROOT/'release_selection.json')
    require(release['raw_predictions_sha256']==result['predictions_sha256'],'Release selection/raw inference binding changed')
    require(selected,'No candidate passed strict classification and exactK gates; report gaps without fabricated tasks')
    require(digest(ROOT/'private/predictions.jsonl')==result['predictions_sha256'],'Predictions changed')
    REQUESTS.mkdir(mode=0o700);(REQUESTS/'cases').mkdir();(REQUESTS/'examples').mkdir()
    formal,rows,_=load_formal_evidence(read(FORMAL_SOURCE)); classes=read(ROOT/'classes.json')
    training=jsonl(ROOT/'private/training.jsonl');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):
            image=Image.open(formal/r['source']['image']).convert('RGB');path=f'examples/class{info["class_id"]}_{i}.png'
            draw_case(image,r['polygon'],r['roi']).save(REQUESTS/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={}
    for pred in selected:
        cls=pred['classified_class_id'];info=classes[str(cls)];key=pred['target_key']
        require(pred['classification_gate_passed'] and pred['geometry_gate_passed'] and len(pred['polygon'])==info['K'],'Invalid strictK selected task')
        row=rows[key];require(row==pred['source'] and digest(formal/row['image'])==pred['image_sha256'],'Original source changed')
        image=Image.open(formal/row['image']).convert('RGB');draw_case(image,pred['polygon'],pred['roi']).save(REQUESTS/'cases'/f'{key}.png')
        images[f'images/{key}.png']=dict(formal_relative_image=row['image'],sha256=pred['image_sha256'])
        proposals.append(dict(schema=NAMESPACE,target_key=key,class_id=cls,K=info['K'],parent=info['parent'],
            polygon=pred['polygon'],source=row,roi=pred['roi'],image_sha256=pred['image_sha256'],
            pose_payload_raw_sha256=pred['pose_payload_raw_sha256'],classification={k:pred[k] for k in ('fine_candidates','fine_confidence','fine_top2_margin','parent_confidence','prototype_class_id','prototype_cosine')},
            class_graph_revision=read(ROOT/'source_binding.json')['class_graph_revision'],
            geometry_provenance=pred['conversion'],checkpoint_sha256=pred['checkpoint_sha256'],
            original_formal_class_id=row['final_class_id'],new_fine_class_is_separate_sidecar=True,
            different_original_image_not_in_prior_human_pool=True,template_used=False,quality_override_used=False,propagation_seed_eligible=False,**FALSE_FLAGS))
    write(REQUESTS/'proposals.jsonl',proposals,lines=True);write(REQUESTS/'classes.json',classes)
    write(REQUESTS/'examples.json',examples);shutil.copyfile(ROOT/'release_quota_report.json',REQUESTS/'quota_report.json')
    with (REQUESTS/'classification.csv').open('x',encoding='utf-8-sig',newline='') as stream:
        fields=['target_key','frame_id','original_formal_class_id','model_fine_candidate','accepted_for_classified_draft','candidate_K','model_polygon_K','fine_score_not_calibrated','fine_top2_margin','model_parent_candidate','parent_confidence','initial_exactK_geometry_gate_passed','release_localization_rejections','included_in_review_queue','fine_candidates','classification_withheld_reasons','geometry_withheld_reasons','image_sha256','checkpoint_sha256']
        writer=csv.DictWriter(stream,fieldnames=fields);writer.writeheader();selected_keys={p['target_key'] for p in proposals}
        parent_names={p['index']:name for name,p in read(ROOT/'parents.json').items()}
        localization={c['target_key']:c['rejected_reasons'] for c in jsonl(ROOT/'private/release_localization_checks.jsonl')}
        for p in jsonl(ROOT/'private/predictions.jsonl'):
            writer.writerow(dict(target_key=p['target_key'],frame_id=p['source']['frame_id'],original_formal_class_id=p['source']['final_class_id'],
                model_fine_candidate=p['candidate_class_id'],accepted_for_classified_draft=p['classified_class_id'],candidate_K=p['requested_K'],
                model_polygon_K=p['actual_K'],fine_score_not_calibrated=p['fine_confidence'],fine_top2_margin=p['fine_top2_margin'],
                model_parent_candidate=parent_names[p['parent_candidate_index']],parent_confidence=p['parent_confidence'],initial_exactK_geometry_gate_passed=p['geometry_gate_passed'],release_localization_rejections=';'.join(localization.get(p['target_key'],[])),
                included_in_review_queue=p['target_key'] in selected_keys,fine_candidates=json.dumps(p['fine_candidates'],ensure_ascii=False),
                classification_withheld_reasons=';'.join(p['classification_withheld_reasons']),geometry_withheld_reasons=';'.join(p['geometry_withheld_reasons']),
                image_sha256=p['image_sha256'],checkpoint_sha256=p['checkpoint_sha256']))
    write(REQUESTS/'summary.json',dict(targets=len(proposals),requested_images=4100,gap=4100-len(proposals),
        candidate_targets=result['candidate_targets'],unresolved_classification_targets=result['candidate_targets']-result['classification_pass_targets'],
        class_graph_revision=read(ROOT/'source_binding.json')['class_graph_revision'],
        independent_metrics=read(RUN/'independent_branch/holdout_metrics.json'),
        independent_coverage=read(RUN/'independent_branch/coverage_audit.json'),
        quality_is_not_certified_until_human_review=True,excluded_classes=[37,47]))
    for name in ('page.html','review.js','review.css'):shutil.copyfile(ASSETS/name,REQUESTS/name)
    from scripts.build_mask_remaining_direct_requests import build_font
    build_font(REQUESTS,(REQUESTS/'page.html').read_text()+(REQUESTS/'review.js').read_text()+json.dumps(classes,ensure_ascii=False))
    # Serve only explicitly allowlisted static originals by bytes; no native
    # images are rewritten, copied wholesale, or looked up from URL paths.
    assets={str(p.relative_to(REQUESTS)):digest(p) for p in REQUESTS.rglob('*') if p.is_file() and p.name!='proposals.jsonl'}
    write(REQUESTS/'manifest.json',dict(schema=NAMESPACE,request_count=len(proposals),source_graph_revision=5,
        proposals_sha256=digest(REQUESTS/'proposals.jsonl'),public_assets=assets,original_images=images,
        training_dataset_manifest_sha256=digest(ROOT/'dataset_manifest.json'),
        checkpoint_sha256=digest(RUN/'full_pool/final_ema.pt'),
        source_binding_sha256=digest(ROOT/'source_binding.json'),
        inference_predictions_sha256=digest(ROOT/'private/predictions.jsonl'),
        original_source_files_modified=False,**FALSE_FLAGS))
    require(sources_current(),'Concurrent source edit; no release')
    print(dict(state='strict_fine_class_tasks_built_pending_independent_UI_acceptance',targets=len(proposals),gap=4100-len(proposals)),flush=True)


class TaxonomyEditor:
    def __init__(self,gallery,directory,key):
        directory=Path(directory).resolve()
        require(directory==REVIEWS or directory.is_relative_to(Path('/tmp/opencode')), 'Independent taxonomy review store required')
        require(len(key.strip())>=20,'Original access credential required')
        self.gallery=gallery;self.access_key=key.strip();self.binding=gallery.manifest_sha256
        self.cookie_token=hmac.new(self.access_key.encode(),NAMESPACE.encode(),hashlib.sha256).hexdigest()
        self.store=MaskReviewStore(directory,self.binding);self.proposals=gallery.proposals
        with closing(self.store.connect()) as db:
            old=db.execute("SELECT value FROM metadata WHERE key='namespace'").fetchone()
            require(not old or old[0]==NAMESPACE,'Do not rebind original taxonomy review history')
            db.execute('INSERT OR IGNORE INTO metadata VALUES (?,?)',('namespace',NAMESPACE))

    def proposal(self,key):
        if key not in self.proposals:raise ReviewError(404,'目标不在本批新复核任务中')
        return self.proposals[key]

    def detail(self,key):
        p=self.proposal(key);current=self.store.get(key)
        return dict(proposal=p,review=current,history=self.store.history(key),binding=self.binding,
            source_binding=sha(p),source_current=sources_current())

    def save(self,key,data):
        p=self.proposal(key)
        if data.get('binding')!=self.binding or data.get('source_binding')!=sha(p):raise ReviewError(409,'任务版本已改变，本机草稿保留，不覆盖旧修订')
        if not sources_current():raise ReviewError(409,'来源类别／原人工历史有新版本，本机草稿保留，需重新整合任务')
        expected=data.get('expected_revision');reviewer=data.get('reviewer');note=data.get('note','');action=data.get('action')
        if type(expected)is not int or expected<0 or not isinstance(reviewer,str) or not 1<=len(reviewer.strip())<=80 or not isinstance(note,str) or len(note)>2000 or action not in ('draft','correct','defer'):
            raise ReviewError(400,'请填写标注人、有效操作与修订版本；备注为选填')
        cls=data.get('class_id');info=self.gallery.classes.get(str(cls))
        if type(cls)is not int or not info or not info['train_enabled']:raise ReviewError(400,'请选择有效细类；Class37/47暂未解决')
        try:polygon=polygon_value(data.get('polygon'),*p['source']['size'])
        except (TypeError,ValueError) as e:raise ReviewError(400,str(e)) from e
        if action=='correct' and len(polygon)!=info['K']:raise ReviewError(400,f'改为Class{cls}后必须为K{info["K"]}，当前{len(polygon)}点；本机草稿保留，可先存草稿')
        restored=data.get('restored_from_revision')
        if restored is not None and (type(restored)is not int or restored not in {h['revision'] for h in self.store.history(key)}):raise ReviewError(400,'恢复历史不存在')
        value=dict(target_key=key,binding=self.binding,source_binding=sha(p),base_proposal_id=sha(p),
            class_id=cls,expected_K=info['K'],polygon=polygon,vertex_count=len(polygon),class_K_matches=len(polygon)==info['K'],
            original_formal_class_id=p['original_formal_class_id'],initial_proposed_class_id=p['class_id'],
            action=action,reviewer=reviewer.strip(),note=note.strip(),restored_from_revision=restored,
            event_kind='human_new_fine_class_mask_review',source=p['source'],checkpoint_sha256=p['checkpoint_sha256'],
            human_review_action=True,formal_class_or_polygon_written=False,original_proposal_modified=False,
            automatic_GT_training_or_robot_promotion=False,propagation_seed_eligible=False,**FALSE_FLAGS)
        return self.store.save(key,expected,value)

    def export(self,key,kind):
        p=self.proposal(key);saved=self.store.get(key)
        if not saved:raise ReviewError(409,'需真实人工保存后才能导出人工修订')
        if not sources_current():raise ReviewError(409,'来源有新版本；保留已保存历史，但不以旧任务导出当前标签')
        if kind=='mask.png':
            mask=raster_mask(saved['polygon'],*p['source']['size']);stream=io.BytesIO();Image.fromarray(mask.astype('uint8')*255).save(stream,format='PNG')
            return stream.getvalue(),'image/png',f'{key}_human_mask.png'
        value=dict(version=NAMESPACE,imagePath=f'{key}.png',imageWidth=p['source']['size'][0],imageHeight=p['source']['size'][1],imageData=None,
            shapes=[dict(label=f'Class{saved["class_id"]}',points=saved['polygon'],shape_type='polygon',group_id=p['source']['box_index'],flags=FALSE_FLAGS)],
            review=saved,original_formal_class_id=p['original_formal_class_id'],training_eligible=False)
        return canonical(value),'application/json; charset=utf-8',f'{key}_human.json'


class TaxonomyGallery:
    def __init__(self,directory=REQUESTS,reviews=REVIEWS,key=None,*,accept_unverified=False):
        self.root=Path(directory).resolve();m=read(self.root/'manifest.json');self.manifest_sha256=digest(self.root/'manifest.json')
        if not accept_unverified:
            seal=read(self.root/'verification.json')
            require(seal['manifest_sha256']==self.manifest_sha256 and seal['state']=='passed_independent_taxonomy_sources_K_quota_and_images','Independent source/K verification required')
        require(digest(self.root/'proposals.jsonl')==m['proposals_sha256'],'Task inventory changed')
        self.proposals={p['target_key']:p for p in jsonl(self.root/'proposals.jsonl')};self.classes=read(self.root/'classes.json')
        self.count=len(self.proposals);require(self.count==m['request_count'],'Duplicate/missing task identities')
        for p in self.proposals.values():
            require(len(p['polygon'])==p['K']==self.classes[str(p['class_id'])]['K'],'Initial classK mismatch')
            require(not p['template_used'] and not p['quality_override_used'],'No template/quality bypass permission in this task')
            polygon_value(p['polygon'],*p['source']['size'])
        self.publication_version=NAMESPACE;self.manual_request_count=0;self.request_page=None;self.edited_page=None
        self.assets={};mime={'.html':'text/html; charset=utf-8','.js':'text/javascript; charset=utf-8','.css':'text/css; charset=utf-8','.json':'application/json; charset=utf-8','.png':'image/png','.otf':'font/otf','.txt':'text/plain; charset=utf-8','.csv':'text/csv; charset=utf-8'}
        for name,h in m['public_assets'].items():
            path=(self.root/name).resolve();require(path.is_relative_to(self.root) and not path.is_symlink() and digest(path)==h,'Public asset changed')
            self.assets['/'+name]=(path,mime[path.suffix],h)
        ui_path=self.root/'ui_revision.json'
        if ui_path.exists():
            ui=read(ui_path)
            require(ui['base_manifest_sha256']==self.manifest_sha256 and ui['schema']=='taxonomy-original-note-font-fix-v2','Unknown UI revision binding')
            require(set(ui['assets'])=={'review.css'},'UI revision may only replace presentation CSS')
            for name,asset in ui['assets'].items():
                path=(self.root/asset['path']).resolve()
                require(path.is_relative_to(self.root/'ui_v2') and not path.is_symlink() and digest(path)==asset['sha256'],'UI font-fix asset changed')
                self.assets['/'+name]=(path,mime[path.suffix],asset['sha256'])
        self.assets['/report_zh.html']=self.assets['/page.html']
        formal,_,_=load_formal_evidence(read(FORMAL_SOURCE))
        for name,value in m['original_images'].items():
            path=(formal/value['formal_relative_image']).resolve();require(path.is_relative_to(formal.resolve()) and digest(path)==value['sha256'],'Original image changed')
            self.assets['/'+name]=(path,'image/png',value['sha256'])
        self.csp="default-src 'none'; img-src 'self'; font-src 'self'; style-src 'self'; script-src 'self'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'"
        self.editor=TaxonomyEditor(self,reviews,key)


class TaxonomyHandler(Handler):
    def review_route(self,path):
        if path=='/api/review/summary' and self.command in ('GET','HEAD'):
            if not self.authenticated():raise ReviewError(401,'请沿用原访问码登录')
            values=self.server.gallery.editor.store.summary()
            return self.json(dict(reviews={k:{field:v[field] for field in ('revision','reviewer','updated_at','action','class_id')} for k,v in values.items() if k in self.server.gallery.proposals}))
        if path in ('/api/review/catalog','/api/review/unresolved') and self.command in ('GET','HEAD'):
            if not self.authenticated():raise ReviewError(401,'请沿用原访问码登录')
            if path.endswith('catalog'):
                return self.json(dict(classes=self.server.gallery.classes,examples=read(self.server.gallery.root/'examples.json'),
                    quotas=read(self.server.gallery.root/'quota_report.json'),summary=read(self.server.gallery.root/'summary.json'),
                    targets=[{k:p[k] for k in ('target_key','class_id','K','classification')} for p in self.server.gallery.proposals.values()]))
            predictions=jsonl(ROOT/'private/predictions.jsonl')
            unresolved=[p for p in predictions if not p['classification_gate_passed']]
            return self.json(dict(count=len(unresolved),not_counted_as_fine_class_quota=True,
                examples=[{k:p[k] for k in ('target_key','candidate_class_id','fine_candidates','classification_withheld_reasons')} for p in unresolved[:100]]))
        return super().review_route(path)
