"""Authentic model-prelabel UI, isolated append-only manual history, not GT."""
from contextlib import closing
import base64
import hashlib
import hmac
import html
import json
from pathlib import Path
import re
import sqlite3

from .mask_gallery import ASSETS, Handler
from .mask_gallery_review import MaskEditor, ReviewError
from .mask_model_worklist import SCHEMA, FLAGS, validate_proposal
from .cluster_targets import digest
from .pose_review_geometry import canonical, polygon_value

PROJECT=Path(__file__).resolve().parents[1]
KEYPOINT_PAUSE=PROJECT/'outputs/pallet_mask_model_managed_v1/keypoint_alignment_pause.json'
HUMAN_KEYPOINT_EDIT_POLICY='human_keypoint_fine_adjustment_add_remove_v1'


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


def keypoint_pause():
    """Mutable safety hold, separate from immutable predictions and human events."""
    if not KEYPOINT_PAUSE.exists():return None
    try:
        value=json.loads(KEYPOINT_PAUSE.read_text())
        if not isinstance(value,dict) or value.get('active') is not True:raise ValueError('Invalid pause declaration')
        return value
    except (OSError,ValueError,TypeError):
        return dict(active=True,reason_zh='类别关键点规范核对中；本机草稿和原人工历史保留')


def editor_js():
    text=(ASSETS/'editor.js').read_text()
    text=text.replace("'mask-gallery-v1:'","'mask-model-native-v1:'")
    # No false assistant-visual/template/human quality attribution in diagnostics.
    return text.replace("'机器建议 · 尚未人工保存'","'M2模型预标注 · 尚未人工复核，保存前不计完成'")


class ModelMaskEditor(MaskEditor):
    def validate(self,p):
        validator=getattr(self.gallery,'validate',validate_proposal)
        return validator(p)

    def __init__(self,gallery,directory,key):
        directory=Path(directory).resolve()
        if directory.parent!=PROJECT/'outputs' or not directory.name.startswith('pallet_mask_model_reviews_'):
            raise ValueError('Model draft human revisions require a separate versioned store')
        super().__init__(gallery,directory,key)
        namespace=getattr(gallery,'publication_version','model-native-v1')
        self.cookie_token=hmac.new(self.access_key.encode(),('model-mask-review:'+namespace).encode(),hashlib.sha256).hexdigest()
        self.binding=sha(dict(formal=self.formal_manifest_sha256,worklist=gallery.manifest_sha256,namespace=namespace))
        with closing(self.store.connect()) as db:
            for field,value in [('worklist_manifest_sha256',gallery.manifest_sha256),('source_namespace',namespace)]:
                old=db.execute('SELECT value FROM metadata WHERE key=?',(field,)).fetchone()
                if old and old[0]!=value:raise ValueError('Do not rebind existing model human history to another worklist')
                db.execute('INSERT OR IGNORE INTO metadata VALUES (?,?)',(field,value))

    def source_reference(self,key):
        p=self.proposal(key);self.validate(p)
        return dict(origin='actual_M2_checkpoint_inference',target_key=key,model=p['model_provenance'])

    def proposal_dependency_current(self,key):
        p=self.proposal(key);self.validate(p)
        for name,table,field in [('pallet_pose_human_review_v1/annotations.sqlite3','annotations','pose_payload_raw_sha256'),
                ('pallet_mask_gallery_reviews_v1/mask_reviews.sqlite3','reviews','gallery_payload_raw_sha256')]:
            path=(PROJECT/'outputs'/name).resolve()
            with closing(sqlite3.connect(path.as_uri()+'?mode=ro',uri=True)) as db:
                row=db.execute(f'SELECT payload FROM {table} WHERE target_key=?',(key,)).fetchone()
            if (hashlib.sha256(row[0].encode()).hexdigest() if row else None)!=p[field]:return False
        return True

    def detail(self,key):
        value=super().detail(key)
        value.update(model_preannotation_source=True,model_provenance=self.proposal(key)['model_provenance'],model_quality_not_certified=True)
        if 'class_keypoint_constraint' in self.proposal(key):
            value['class_keypoint_constraint']=self.proposal(key)['class_keypoint_constraint']
            value['human_keypoint_count_editing_allowed']=getattr(self.gallery,'allow_class_keypoint_count_changes',False) is True
        return value

    def save(self,key,data):
        p=self.proposal(key);self.validate(p)
        if data.get('binding')!=self.binding or data.get('source_binding')!=self.source_binding(key) or data.get('proposal_id')!=sha(p):
            raise ReviewError(409,'模型任务或目标绑定已变，本机草稿保留')
        expected=data.get('expected_revision');reviewer=data.get('reviewer','');note=data.get('note','')
        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:
            raise ReviewError(400,'请填写有效标注人、备注及修订版本')
        if not self.proposal_dependency_current(key):raise ReviewError(409,'源目标已被其它工具修订，本机草稿保留，不覆盖历史')
        old=self.store.get(key)
        if old and old['source_binding']!=self.source_binding(key):raise ReviewError(409,'原图或目标绑定已变化，不覆盖原人工修订')
        try:polygon=polygon_value(data.get('polygon'),*p['source']['size'])
        except (ValueError,TypeError) as error:raise ReviewError(400,str(error)) from error
        constraint=p.get('class_keypoint_constraint')
        human_count_editing=getattr(self.gallery,'allow_class_keypoint_count_changes',False) is True
        if constraint and len(polygon)!=constraint['standard_count'] and not human_count_editing:
            raise ReviewError(400,f'Class {p["class_id"]} 必须保留 {constraint["standard_count"]} 个关键点；当前未保存，本机草稿保留')
        restored=data.get('restored_from_revision')
        if restored is not None and (type(restored) is not int or restored not in {r['revision'] for r in self.store.history(key)}):raise ReviewError(400,'恢复来源修订不存在')
        value=dict(target_key=key,source=self.identity(key),source_binding=self.source_binding(key),binding=self.binding,
            base_proposal_id=sha(p),proposal_publication=getattr(self.gallery,'publication_version','model-native-v1'),worklist_manifest_sha256=self.gallery.manifest_sha256,
            proposal_polygon=p['polygon'],polygon=polygon,vertex_count=len(polygon),original_vertex_count=p['vertex_count'],
            reviewer=reviewer.strip(),note=note.strip(),restored_from_revision=restored,status='human_edited_draft_pending_confirmation',
            event_kind='human_model_mask_review',mask_semantics=p['mask_semantics'],model_provenance=p['model_provenance'],
            human_edited=True,human_mask_confirmed=False,human_pose_confirmed=False,ground_truth_eligible=False,
            automatic_training_eligible=False,robot_command_eligible=False,propagation_seed_eligible=False,
            pose_store_written=False,original_proposal_modified=False,accepted_candidate=False,
            geometry_changed_from_model=polygon!=p['polygon'],human_review_save_action=True,
            accepted_model_without_geometry_change=polygon==p['polygon'],
            actual_human_save_not_automatic_quota_or_GT_promotion=True)
        if constraint:
            value['class_keypoint_constraint']=constraint
            if human_count_editing:
                count=len(polygon);standard=constraint['standard_count'];previous=len(old['polygon']) if old else len(p['polygon'])
                value['human_keypoint_editing']=dict(policy=HUMAN_KEYPOINT_EDIT_POLICY,
                    standard_applies_to='initial_machine_proposal_only',initial_standard_count=standard,
                    actual_saved_count=count,delta_from_standard=count-standard,standard_count_matches=count==standard,
                    previous_saved_or_initial_count=previous,point_count_changed_from_previous=count!=previous)
        prepare_value=getattr(self,'prepare_saved_value',None)
        if prepare_value is not None:value=prepare_value(p,value)
        return self.store.save(key,expected,value)

    def export(self,key,kind):
        raw,mime,name=super().export(key,kind)
        constraint=self.proposal(key).get('class_keypoint_constraint')
        if kind=='labelme.json' and constraint:
            value=json.loads(raw);polygon=value['shapes'][0]['points']
            value['class_keypoint_constraint']=constraint
            value['keypoints_xy']=polygon;value['num_keypoints']=len(polygon)
            value['initial_standard_keypoint_count']=constraint['standard_count']
            value['keypoint_count_matches_class_standard']=len(polygon)==constraint['standard_count']
            value['human_keypoint_editing']=value['mask_gallery_review'].get('human_keypoint_editing')
            value['keypoint_order_semantics']='clockwise geometric slots, physical semantic correspondence not confirmed'
            value['shapes'].extend(dict(label=f'kp_{i:02d}',shape_type='point',points=[point],group_id=self.proposal(key)['source']['box_index'],
                flags=dict(human_edited=True,human_confirmed=False)) for i,point in enumerate(polygon,1))
            raw=canonical(value)
        return raw,mime,name


class ModelMaskGallery:
    verification_state='passed_model_sources_exports_protection_not_accuracy'
    publication_namespace='model-native-v1'

    def validate(self,p):validate_proposal(p)

    def __init__(self,root,reviews,key):
        self.root=Path(root).resolve();m=json.loads((self.root/'manifest.json').read_text());v=json.loads((self.root/'verification.json').read_text())
        self.manifest_sha256=digest(self.root/'manifest.json')
        if v['state']!=self.verification_state or v['manifest_sha256']!=self.manifest_sha256 or v['public_assets']!=m['public_assets']:
            raise ValueError('Model draft package has no matching read-only structural seal')
        self.proposals={p['target_key']:p for p in map(json.loads,(self.root/'proposals.jsonl').read_text().splitlines())}
        self.proposals_sha256=digest(self.root/'proposals.jsonl')
        if self.proposals_sha256!=m['proposals_sha256'] or len(self.proposals)!=m['request_count']:raise ValueError('Model inventory differs')
        self.count=len(self.proposals);self.publication_version=self.publication_namespace;self.manual_request_count=self.count;self.preannotation_proposals={}
        allowed={'report_zh.html','report-font.otf','FONT_LICENSE.txt','model-editor.js'}
        allowed.update(f'{folder}/{k}.{ext}' for k in self.proposals for folder,ext in [('images','png'),('cases','png'),('masks','png'),('labelme','json')])
        if set(m['public_assets'])!=allowed:raise ValueError('Unexpected public model resource')
        self.assets={}
        for name,expected in m['public_assets'].items():
            path=(self.root/name).resolve()
            if not path.is_relative_to(self.root) or path.is_symlink() or digest(path)!=expected:raise ValueError('Public model asset changed')
            mime={'.html':'text/html; charset=utf-8','.png':'image/png','.json':'application/json; charset=utf-8','.js':'text/javascript; charset=utf-8','.txt':'text/plain; charset=utf-8','.otf':'font/otf'}[path.suffix]
            self.assets['/'+name]=(path,mime,expected)
        for p in self.proposals.values():
            self.validate(p)
            if p['model_source_image_sha256']!=m['public_assets'][f'images/{p["target_key"]}.png']:raise ValueError('Image/proposal mismatch')
        self.assets['/review-ui/editor.js']=self.assets['/model-editor.js']
        for name,mime in [('editor.css','text/css; charset=utf-8'),('editor-font.otf','font/otf'),('FONT_LICENSE.txt','text/plain; charset=utf-8')]:
            path=ASSETS/name;self.assets['/review-ui/'+name]=(path,mime,digest(path))
        self.editor=getattr(self,'editor_class',ModelMaskEditor)(self,reviews,key)
        page=(self.root/'report_zh.html').read_text();fragment=(ASSETS/'editor.html').read_text()
        fragment=fragment.replace('不覆盖机器建议、位姿或原始标注。','不覆盖机器建议、位姿或原始标注。本批为M2真实预测，保留模型/任务/目标来源；不自动确认GT或回灌训练。')
        self.edited_page=page.replace('</html>',fragment+'</html>').encode();self.request_page=None
        hashes=["'sha256-"+base64.b64encode(hashlib.sha256(s.encode()).digest()).decode()+"'" for s in re.findall(r'<script>(.*?)</script>',page,re.S)]
        self.csp="default-src 'none'; img-src 'self'; font-src 'self'; connect-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self' "+' '.join(hashes)+"; base-uri 'none'; form-action 'self'; frame-ancestors 'none'"


class ModelMaskHandler(Handler):
    def route(self):
        from urllib.parse import urlsplit,unquote
        path=unquote(urlsplit(self.path).path)
        publication=getattr(self.server.gallery,'publication_version','model-native-v1')
        pause=keypoint_pause() if publication=='model-native-v1' else None
        if path=='/healthz' and self.command in ('GET','HEAD'):
            return self.json(dict(status='ok',service='pallet_mask_model_preannotation_review',targets=self.server.gallery.count,
                editing_enabled=pause is None,keypoint_alignment_paused=pause is not None,
                active_draft_targets=0 if pause else self.server.gallery.count,
                human_keypoint_add_enabled=getattr(self.server.gallery,'allow_class_keypoint_count_changes',False) is True,
                model='M2 full-pool final EMA',machine_drafts_not_human_completed=True,publication_version=publication,
                separate_model_review_history=True,old_services_replaced=False))
        if pause:
            message=pause.get('reason_zh','类别关键点数量及编号核对中；本机草稿和原人工历史保留')
            if path in ('/','/report_zh.html') and self.command in ('GET','HEAD'):
                replacement=pause.get('successor_public_url','');parsed=urlsplit(replacement)
                safe_successor=(parsed.scheme=='https' and parsed.hostname and parsed.hostname.endswith('.trycloudflare.com')
                    and not parsed.username and not parsed.password and not parsed.query and not parsed.fragment)
                notice=('<p><a href="'+html.escape(replacement,quote=True)+'">进入已核验的类别标准点数关键点新版（337张）</a>，沿用原访问码。旧密集草稿仍保持暂停，不会覆盖新旧人工历史。</p>' if safe_successor else
                    '<p>尚未发布类别点数校正后的新版本，请勿把旧密集边界当作标准关键点。</p>')
                page='<!doctype html><html lang="zh-CN"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>预标注已暂停 · 校对类别关键点</title><body style="font:18px/1.7 sans-serif;max-width:900px;margin:40px auto;padding:16px"><h1>本批预标注已暂停</h1><p>'+html.escape(message)+'</p><p>原机器预测、人工保存和历史均保留，未清除本机草稿。原访问码和当前网址不变；旧图库及其它标注入口不受影响。</p>'+notice+'</body></html>'
                return self.respond(200,page.encode(),'text/html; charset=utf-8')
            if (path.startswith(('/api/review/targets/','/api/review/annotations/','/cases/','/masks/','/labelme/'))):
                raise ReviewError(503,message+'；当前未保存，不跳转，本机草稿保留')
        return super().route()
