"""Versioned integration of user-declared completed note edits into class review.

The original421 class history, note-review actions (including draft), and frozen
polygons are not rewritten. A new review epoch owns the updated display/labels.
"""
from collections import Counter
from contextlib import closing
import csv
import hashlib
import html
import io
import json
from pathlib import Path
import re
import shutil
import sqlite3

import numpy as np
from PIL import Image,ImageDraw

from .mask_class_correction import ROOT as BASE,STATE as BASE_STATE,NAMESPACE as BASE_NAMESPACE
from .mask_class_correction_review import ClassReviewer,ClassHandler,compute
from .mask_class_note_corrections import ROOT as NOTES,STATE as NOTE_STATE
from .mask_gallery_review import ReviewError
from .mask_model_training_data import PROJECT,read,write,jsonl,require
from .mask_quality_recovery import fingerprint
from .mask_template_refined import readonly
from .pose_review_geometry import canonical,polygon_value
from .cluster_targets import digest

ROOT=PROJECT/'outputs/pallet_mask_class_note_integrated_v1'
STATE=PROJECT/'outputs/pallet_mask_class_note_integrated_reviews_v1'
CHECKS=PROJECT/'outputs/pallet_mask_class_note_integrated_checks_v1'
ACTIVE=PROJECT/'outputs/pallet_mask_class_correction_managed_v1/note_integration_active.json'
NAMESPACE='human2200-class-note-integrated-v1'
AUTHORIZATION='已经完成可以修改的标注，对应更新类别复核服务'


def sha(value):return hashlib.sha256(canonical(value)).hexdigest()


def read_db(path,key=None):
    with closing(readonly(path)) as db:
        db.execute('BEGIN');reviews=list(db.execute('SELECT target_key,revision,payload FROM reviews'));events=list(db.execute('SELECT target_key,revision,payload FROM events ORDER BY id'));metadata=dict(db.execute('SELECT key,value FROM metadata'))
    if key is not None:require(any(k==key for k,_,_ in reviews),'Required graph missing')
    return reviews,events,metadata


def plan(records,graph,note_values,tasks):
    """Explicit user completion is required; matching K alone never completes a draft."""
    require(graph['authorization']==AUTHORIZATION,'Explicit user completion/integration authorization required')
    state=json.loads(json.dumps(graph['state']));original_groups,_=compute(records,state)
    require(all(state['group_status'].get(f)=='confirm' for f in original_groups),'Source classes not all confirmed')
    byclass={g['proposed_class_id']:f for f,g in original_groups.items()};bykey={r['target_key']:r for r in records}
    updated=json.loads(json.dumps(records));updated_bykey={r['target_key']:r for r in updated};imported={};unresolved={}
    for key,p in tasks.items():
        saved=note_values.get(key)
        if saved is None or saved['action'] not in ('correct','draft'):
            unresolved[key]=dict(source_class_id=p['class_id'],original_K=p['actual_K'],action=saved['action'] if saved else 'unsaved',annotation=p['class_note']['annotation']);continue
        require(p['kind'] in ('reannotate','reannotate_and_move'),'Occluded, excluded or ambiguous tasks require their explicit handling, not bulk draft completion')
        require(saved['source_binding']==sha(p) and saved['base_proposal_id']==sha(p) and saved['source_class_graph_revision']==graph['revision'],'Saved note/source binding changed')
        require(saved['source_class_id']==p['class_id'] and saved['requested_target_class_id']==p['target_class_id'],'Requested Class differs from frozen instruction')
        require(saved.get('effective_class_id')==(p['target_class_id'] if saved['action']=='correct' else None),'Original note completion/action fields are inconsistent')
        require(state['assignments'][key]==p['face_id'] and bykey[key]['polygon']==p['polygon'],'Base class/polygon changed since note worklist')
        polygon=polygon_value(saved['polygon'],*p['source']['size'])
        require(len(polygon)==p['expected_K'] and saved['vertex_count']==len(polygon),'Saved completed polygon does not have required actual K')
        require(polygon!=p['polygon'],'User completion must refer to an actual modified human contour')
        destination=p['target_class_id'];require(destination in byclass,'Instruction destination Class missing')
        if destination!=p['class_id']:require(original_groups[byclass[destination]]['K']==len(polygon),'Cross-K destination is forbidden after contour editing')
        r=updated_bykey[key];proof=dict(source_class_id=p['class_id'],destination_class_id=destination,old_K=p['actual_K'],new_K=len(polygon),
            original_polygon_sha256=sha(p['polygon']),new_polygon_sha256=sha(polygon),note_revision=saved['revision'],note_original_action=saved['action'],
            note_payload_sha256=sha(saved),source_note_revision=p['class_note']['note_revision'],source_note_text=p['class_note']['full_review_note'],
            completion_basis='existing_explicit_correct_save' if saved['action']=='correct' else 'explicit_user_completed_annotations_integration_request')
        imported[key]=proof
        r.update(polygon=polygon,actual_K=len(polygon),source_revision=saved['revision'],source_payload_sha256=sha(saved),
            source_event_raw_sha256=graph['note_raw_hashes'][key],source_batch=NAMESPACE,geometry_source_kind='integrated_latest_human_note_revision',
            original_human_source=dict(revision=bykey[key]['source_revision'],event_raw_sha256=bykey[key]['source_event_raw_sha256'],polygon_sha256=sha(p['polygon'])),
            note_integration=proof)
        state['assignments'][key]=byclass[destination]
    require(imported,'No valid saved contours to integrate')
    # A whole class changing actualK must not be silently split or mixed.
    for f in set(state['assignments'].values()):
        require(len({r['actual_K'] for r in updated if state['assignments'][r['target_key']]==f})==1,'Partial Class K migration would create a mixed-K face group')
    alive=set(state['assignments'].values())
    state['group_status']={f:s for f,s in state['group_status'].items() if f in alive}
    state['anchor_choices']={f:c for f,c in state['anchor_choices'].items() if f in alive}
    state['manual_class_choices']={f:{**choice,'K':next(r['actual_K'] for r in updated if state['assignments'][r['target_key']]==f)} for f,choice in state.get('manual_class_choices',{}).items() if f in alive}
    groups,newids=compute(updated,state);state['new_ids']=newids
    require(all(g['proposed_class_id']==original_groups[f]['proposed_class_id'] for f,g in groups.items()),'Integration unexpectedly renumbered another class')
    require(len({g['proposed_class_id'] for g in groups.values()})==len(groups),'Effective Class collision')
    state['reason']='按用户已完成标注并更新服务的请求，整合最新人工轮廓；原草稿/完成状态及历史均保留于来源库'
    return updated,state,groups,imported,unresolved


def snapshot_db(source,dest):
    with closing(readonly(source)) as db:
        with closing(sqlite3.connect(dest)) as target:db.backup(target)
    dest.chmod(0o600)


def build():
    require(not ROOT.exists(),'Fresh integrated review version required; preserve existing package')
    base_rows,base_events,base_meta=read_db(BASE_STATE/'mask_reviews.sqlite3','class_graph')
    _,revision,raw=next(row for row in base_rows if row[0]=='class_graph');base_value=json.loads(raw)
    require(revision==421 and base_meta['class_graph_binding']==digest(BASE/'manifest.json'),'Expected completed421 source changed')
    note_rows,note_events,note_meta=read_db(NOTE_STATE/'mask_reviews.sqlite3');note_values={k:json.loads(raw) for k,_,raw in note_rows}
    tasks={p['target_key']:p for p in jsonl(NOTES/'tasks.jsonl')};deps=read(NOTES/'private/dependencies.json')
    require(note_meta['formal_manifest_sha256']==digest(NOTES/'manifest.json') and hashlib.sha256(raw.encode()).hexdigest()==deps['class_graph_raw_sha256'],'Note task/current class source binding differs')
    require(all(fingerprint(PROJECT/p)==h for p,h in deps['human_source_fingerprints'].items()),'Old human source store changed')
    last_raw={k:raw for k,_,raw in note_events};require({k:json.loads(raw) for k,raw in last_raw.items()}==note_values,'Current note revisions differ from their final raw events')
    records=jsonl(BASE/'private/records.jsonl');updated,state,groups,imported,unresolved=plan(records,dict(state=base_value['state'],revision=revision,authorization=AUTHORIZATION,note_raw_hashes={k:hashlib.sha256(v.encode()).hexdigest() for k,v in last_raw.items()}),note_values,tasks)
    ROOT.mkdir(mode=0o700);(ROOT/'private').mkdir(mode=0o700)
    snapshot_db(BASE_STATE/'mask_reviews.sqlite3',ROOT/'private/source_class_reviews.sqlite3');snapshot_db(NOTE_STATE/'mask_reviews.sqlite3',ROOT/'private/source_note_reviews.sqlite3')
    write(ROOT/'private/records_before.jsonl',records,lines=True);write(ROOT/'private/records.jsonl',updated,lines=True)
    write(ROOT/'private/initial_state.json',state);write(ROOT/'assignments.json',state['assignments']);write(ROOT/'new_class_registry.json',state['new_ids'])
    classes=read(NOTES/'classes.json');byface={v['face_id']:v for v in classes.values()}
    attributes={f:byface[f] for f in groups};write(ROOT/'class_attributes.json',attributes);write(ROOT/'face_groups.json',groups)
    write(ROOT/'targets.json',[dict(target_key=r['target_key'],old_class_id=r['old_class_id'],actual_K=r['actual_K'],source_revision=r['source_revision'],image_sha256=r['image_sha256'],vote_unit=r['vote_unit']) for r in updated])
    write(ROOT/'integrated_targets.json',imported);write(ROOT/'unresolved_notes.json',unresolved)
    report=dict(source_class_graph_revision=421,source_class_events=len(base_events),source_note_events=len(note_events),source_note_saved_targets=len(note_rows),
        authorization=AUTHORIZATION,integrated_targets=len(imported),original_saved_actions=dict(Counter(p['note_original_action'] for p in imported.values())),
        integrated_per_source_class=dict(Counter(p['source_class_id'] for p in imported.values())),
        actual_K_histogram=dict(Counter(r['actual_K'] for r in updated)),class_count_before=len(classes),class_count_after=len(groups),
        retired_classes=[int(c) for c,v in classes.items() if v['face_id'] not in groups],
        unresolved_notes=list(unresolved.values()),attributes_preserved=True,source_databases_not_written=True,no_training_no_GT_no_propagation=True)
    write(ROOT/'integration_report.json',report)
    base_manifest=read(BASE/'manifest.json')
    for folder in ('images','crops','overlays'):
        (ROOT/folder).mkdir()
        for r in updated:
            key=r['target_key'];source=BASE/folder/f'{key}.png';require(digest(source)==base_manifest['public_assets'][str(source.relative_to(BASE))],'Original public asset changed')
            shutil.copyfile(source,ROOT/folder/f'{key}.png')
    (ROOT/'previous_overlays').mkdir()
    for key in imported:
        shutil.copyfile(BASE/'overlays'/f'{key}.png',ROOT/'previous_overlays'/f'{key}.png')
        r=next(r for r in updated if r['target_key']==key);pts=np.asarray(r['polygon']);b=r['row']['bbox']
        image=Image.open(ROOT/'images'/f'{key}.png').convert('RGB');w,h=image.size
        l=max(0,int(np.floor(min(pts[:,0].min(),b['x'])-8)));t=max(0,int(np.floor(min(pts[:,1].min(),b['y'])-8)))
        right=min(w,int(np.ceil(max(pts[:,0].max(),b['x']+b['width'])+8)));bottom=min(h,int(np.ceil(max(pts[:,1].max(),b['y']+b['height'])+8)))
        crop=image.crop((l,t,right,bottom));crop.save(ROOT/'crops'/f'{key}.png');draw=ImageDraw.Draw(crop)
        points=[(x-l,y-t) for x,y in r['polygon']];draw.line(points+[points[0]],fill='#55d5ff',width=1)
        for i,(x,y) in enumerate(points,1):draw.ellipse((x-1,y-1,x+1,y+1),fill='#ffbe43');draw.text((x+1,y-8),str(i),fill='#ffbe43')
        crop.save(ROOT/'overlays'/f'{key}.png')
    write_assets(ROOT,report)
    fingerprints={**deps['human_source_fingerprints'],str((BASE_STATE/'mask_reviews.sqlite3').relative_to(PROJECT)):fingerprint(BASE_STATE/'mask_reviews.sqlite3'),str((NOTE_STATE/'mask_reviews.sqlite3').relative_to(PROJECT)):fingerprint(NOTE_STATE/'mask_reviews.sqlite3')}
    write(ROOT/'input_manifest.json',dict(source_fingerprints=fingerprints,source_class_manifest_sha256=digest(BASE/'manifest.json'),source_note_manifest_sha256=digest(NOTES/'manifest.json'),
        source_class_event_raw_hashes=[hashlib.sha256(raw.encode()).hexdigest() for _,_,raw in base_events],source_note_event_raw_hashes=[hashlib.sha256(raw.encode()).hexdigest() for _,_,raw in note_events],
        completed_user_authorization=AUTHORIZATION,scope='latest88_saved_human_edits_no_unsaved_or_unresolved_items'))
    assets={str(p.relative_to(ROOT)):digest(p) for folder in ('images','crops','overlays','previous_overlays') for p in (ROOT/folder).iterdir()}
    for name in ('report_zh.html','review.js','comparison.js','integration.js','report-font.otf','FONT_LICENSE.txt','targets.json','face_groups.json','class_attributes.json','integrated_targets.json','unresolved_notes.json','integration_report.json'):assets[name]=digest(ROOT/name)
    manifest=dict(schema=NAMESPACE,targets=2200,initial_candidate_groups=len(groups),source_records_sha256=digest(ROOT/'private/records.jsonl'),
        original_source_records_sha256=digest(ROOT/'private/records_before.jsonl'),initial_state_sha256=digest(ROOT/'private/initial_state.json'),
        input_manifest_sha256=digest(ROOT/'input_manifest.json'),source_class_graph_revision=421,source_note_events=len(note_events),integrated_targets=len(imported),
        public_assets=assets,old_class_and_note_databases_preserved=True,old_frozen_package_preserved=True,all45_semantic_classes_confirmed_by_source_and_user_completion=True,
        unresolved_note_targets=len(unresolved),no_new_classification_or_correction_accuracy_claim=True,no_training_no_GT_no_propagation=True)
    write(ROOT/'manifest.json',manifest)
    require(read_db(BASE_STATE/'mask_reviews.sqlite3')[0]==base_rows and read_db(NOTE_STATE/'mask_reviews.sqlite3')[0]==note_rows,'Source reviews changed during build; new version required')
    print(report,flush=True)


def write_assets(root,report):
    from scripts.build_mask_remaining_direct_requests import build_font
    source=PROJECT/'pallet/assets/mask_class_correction'
    page=(source/'page.html').read_text().replace('/review-ui/v2/review.js','/review.js').replace('/review-ui/v2/comparison.js','/comparison.js')
    banner=f'''<section id="integrationBanner"><h2>已整合最新人工修改：{report['integrated_targets']}目标</h2><p>本页为独立整合版r1起；原类别图r421及全部421条历史完整保留。Class12/85现为K12，原Class108→14、124→115。原始84条草稿状态未改写，本次用户“已完成并更新”指示作为整合依据。</p><p class="warn">Class37异常项、Class47遮挡项没有本轮保存，仍未解决；不自动排除、不补造遮挡点。分类确认不等于这两条问题已修复。</p><p><a href="/api/review/source-history" target="_blank">查看原421条类别／属性理由历史（只读）</a> · <a href="/api/review/integration-report" target="_blank">下载本轮整合依据</a></p></section>'''
    page=page.replace('<section id="confirmedExamples"',banner+'<section id="confirmedExamples"')
    page=page.replace('<img id="overlayImage" alt="最新人工轮廓">','<img id="overlayImage" alt="最新人工轮廓"><p id="previousLabel" hidden>本轮修改前的人工轮廓（只读对照）</p><img id="previousOverlay" alt="本轮修改前人工轮廓" hidden>')
    page=page.replace('</html>','<script src="/integration.js"></script></html>')
    (root/'report_zh.html').write_text(page)
    js=(source/'review.js').read_text().replace("prefix='class-correction-v1:'","prefix='class-correction-note-integrated-v1:'")
    (root/'review.js').write_text(js);shutil.copyfile(source/'comparison.js',root/'comparison.js')
    integration=(PROJECT/'pallet/assets/mask_class_correction/integration.js').read_text();(root/'integration.js').write_text(integration)
    build_font(root,page+js+integration+json.dumps(read(root/'class_attributes.json'),ensure_ascii=False))


class IntegratedReviewer(ClassReviewer):
    def __init__(self,gallery,directory,key):
        directory=Path(directory).resolve()
        protected=[BASE,BASE_STATE,NOTES,NOTE_STATE,gallery.root,PROJECT/'pallet',PROJECT/'configs',*[(PROJECT/p).parent for p in gallery.inputs['source_fingerprints']]]
        require(all(directory!=p and not directory.is_relative_to(p) and not p.is_relative_to(directory) for p in protected),'Integrated review store must be independent of all source stores/packages')
        super().__init__(gallery,directory,key)
        if self.store.get('class_graph') is None:
            require(self.sources_current(),'Sources changed before initializing integrated review')
            state=read(gallery.root/'private/initial_state.json')
            self.store.save('class_graph',0,dict(state=state,reviewer='system:integrate-user-declared-completed-annotations',action='integrate_note_corrections',note=state['reason'],
                binding=self.binding,source_records_sha256=gallery.manifest['source_records_sha256'],old_classes_overwritten=False,human_polygons_modified=False,
                automatic_training_or_GT_promotion=False,source_class_revision=421,integrated_targets=gallery.report['integrated_targets'],
                user_authorization=AUTHORIZATION,source_note_saved_actions=gallery.report['original_saved_actions'],original_source_databases_written=False))

    def sources_current(self):
        return super().sources_current() and digest(BASE/'manifest.json')==self.gallery.inputs['source_class_manifest_sha256'] and digest(NOTES/'manifest.json')==self.gallery.inputs['source_note_manifest_sha256']

    def get(self):
        result=super().get()
        for f,g in result['groups'].items():
            info=self.gallery.attributes.get(f)
            if info:
                g.update(attributes_text=info['attributes_text'],original_review_note=info['full_review_note'],original_note_revision=info['note_revision'])
            g['integrated_note_targets']=sum(k in self.gallery.integrated for k,face in result['state']['assignments'].items() if face==f)
            g['unresolved_note_targets']=sum(k in self.gallery.unresolved for k,face in result['state']['assignments'].items() if face==f)
        result.update(integration_report=self.gallery.report,integrated_target_keys=sorted(self.gallery.integrated),source_class_revision=421,publication_version=NAMESPACE)
        return result

    def export(self,confirmed):
        result=super().export(confirmed)
        for row in result['records']:
            proof=self.gallery.integrated.get(row['target_key']);row.update(geometry_source='latest_integrated_note_revision' if proof else 'original_frozen_human_revision',
                original_note_save_action=proof['note_original_action'] if proof else None,integration_completion_basis=proof['completion_basis'] if proof else None,
                source_note_review_revision=proof['note_revision'] if proof else None,unresolved_note=row['target_key'] in self.gallery.unresolved)
        result.update(publication_version=NAMESPACE,source_class_revision=421,integrated_targets=len(self.gallery.integrated))
        return result


class IntegratedGallery:
    def __init__(self,root=ROOT,reviews=STATE,key=None):
        self.root=Path(root).resolve();self.manifest=read(self.root/'manifest.json');self.manifest_sha256=digest(self.root/'manifest.json')
        seal=read(self.root/'verification.json');require(seal['state']=='passed_versioned_note_integration_source_K_and_class_scope' and seal['manifest_sha256']==self.manifest_sha256,'Independent integrated version seal required')
        require(digest(self.root/'private/records.jsonl')==self.manifest['source_records_sha256'] and digest(self.root/'private/initial_state.json')==self.manifest['initial_state_sha256'] and digest(self.root/'input_manifest.json')==self.manifest['input_manifest_sha256'],'Integrated private data changed')
        self.records=jsonl(self.root/'private/records.jsonl');self.inputs=read(self.root/'input_manifest.json');self.attributes=read(self.root/'class_attributes.json');self.integrated=read(self.root/'integrated_targets.json');self.unresolved=read(self.root/'unresolved_notes.json');self.report=read(self.root/'integration_report.json')
        self.count=len(self.records);self.publication_version=NAMESPACE;self.edited_page=None;self.request_page=None;self.assets={}
        for name,h in self.manifest['public_assets'].items():
            path=self.root/name;require(path.resolve().is_relative_to(self.root) and not path.is_symlink() and digest(path)==h,'Integrated asset changed')
            mime={'.html':'text/html; charset=utf-8','.js':'application/javascript; charset=utf-8','.json':'application/json; charset=utf-8','.png':'image/png','.otf':'font/otf','.txt':'text/plain; charset=utf-8'}[path.suffix]
            self.assets['/'+name]=(path,mime,h)
        self.csp="default-src 'none'; img-src 'self'; font-src 'self'; style-src 'unsafe-inline'; script-src 'self'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'"
        self.editor=IntegratedReviewer(self,reviews,key)


class IntegratedHandler(ClassHandler):
    def route(self):
        from urllib.parse import urlsplit
        if urlsplit(self.path).path=='/healthz' and self.command in ('GET','HEAD'):
            return self.json(dict(status='ok',service=BASE_NAMESPACE,publication_version=NAMESPACE,targets=self.server.gallery.count,editing_enabled=True,
                integrated_targets=self.server.gallery.report['integrated_targets'],source_class_graph_revision=421))
        return super().route()

    def review_route(self,path):
        if path in ('/api/review/source-history','/api/review/integration-report') and self.command in ('GET','HEAD'):
            if not self.authenticated():raise ReviewError(401,'登录后读取来源历史')
            if path.endswith('integration-report'):return self.json(self.server.gallery.report)
            with closing(readonly(self.server.gallery.root/'private/source_class_reviews.sqlite3')) as db:rows=[json.loads(raw) for raw, in db.execute("SELECT payload FROM events WHERE target_key='class_graph' ORDER BY revision DESC")]
            return self.json(dict(source_class_revision=421,read_only=True,history=[{k:v.get(k) for k in ('revision','action','reviewer','note','updated_at','face_id')} for v in rows],old_full_raw_history_preserved=True))
        if path in ('/api/review/export/confirmed.csv','/api/review/export/proposals.csv') and self.command in ('GET','HEAD'):
            if not self.authenticated():return super().review_route(path)
            value=self.server.gallery.editor.export('confirmed' in path);stream=io.StringIO()
            fields=['target_key','original_class_id','actual_keypoint_count','face_group','proposed_class_id','corrected_class_id','review_status','published_class_id','effective_label_is_human_confirmed','source_polygon_sha256','class_assignment_method','majority_proposed_class_id','majority_decision','manual_class_id','geometry_source','original_note_save_action','integration_completion_basis','source_note_review_revision','unresolved_note']
            writer=csv.DictWriter(stream,fieldnames=fields);writer.writeheader();writer.writerows(value['records'])
            return self.respond(200,stream.getvalue().encode('utf-8-sig'),'text/csv; charset=utf-8',headers={'Content-Disposition':'attachment; filename="class-correction-integrated.csv"'})
        return super().review_route(path)
