"""Independent, authenticated mask-only review history for the public gallery.

Nothing here writes to pose reviews, frozen proposals, source images or GT.
"""
from __future__ import annotations

from contextlib import closing
from datetime import datetime,timezone
import hashlib
import hmac
import io
import json
import os
from pathlib import Path
import sqlite3

import numpy as np
from PIL import Image

from .pose_review_geometry import canonical,polygon_value,raster_mask
from .mask_pose_dependency import current_pose_source
from .mask_preannotation import SCHEMA as PREANNOTATION_SCHEMA,validate_preannotation,current_preannotation_target

VERSION='mask-gallery-editor-v1'
COOKIE='pallet_mask_gallery_editor_v1'


class ReviewError(Exception):
    def __init__(self,status,message):self.status,self.message=status,message


class MaskReviewStore:
    def __init__(self,directory,formal_manifest_sha256):
        directory=Path(directory).resolve();directory.mkdir(parents=True,exist_ok=True)
        self.path=directory/'mask_reviews.sqlite3'
        with closing(self.connect()) as db:
            db.execute('PRAGMA journal_mode=WAL')
            db.executescript('''
                CREATE TABLE IF NOT EXISTS metadata(key TEXT PRIMARY KEY,value TEXT NOT NULL);
                CREATE TABLE IF NOT EXISTS reviews(target_key TEXT PRIMARY KEY,revision INTEGER NOT NULL,payload TEXT NOT NULL);
                CREATE TABLE IF NOT EXISTS events(id INTEGER PRIMARY KEY AUTOINCREMENT,target_key TEXT NOT NULL,
                    revision INTEGER NOT NULL,payload TEXT NOT NULL,UNIQUE(target_key,revision));
            ''')
            old=db.execute("SELECT value FROM metadata WHERE key='formal_manifest_sha256'").fetchone()
            if old and old[0]!=formal_manifest_sha256:raise ValueError('Mask review store belongs to another formal dataset')
            db.execute('INSERT OR IGNORE INTO metadata VALUES (?,?)',('formal_manifest_sha256',formal_manifest_sha256))
            if db.execute('PRAGMA quick_check').fetchone()[0]!='ok':raise ValueError('Mask review database failed integrity check')
        self.path.chmod(0o600)

    def connect(self):
        db=sqlite3.connect(self.path,timeout=15,isolation_level=None);db.execute('PRAGMA synchronous=FULL');return db

    def get(self,key):
        with closing(self.connect()) as db:row=db.execute('SELECT payload FROM reviews WHERE target_key=?',(key,)).fetchone()
        return json.loads(row[0]) if row else None

    def summary(self):
        with closing(self.connect()) as db:return {k:json.loads(raw) for k,raw in db.execute('SELECT target_key,payload FROM reviews')}

    def history(self,key):
        with closing(self.connect()) as db:return [json.loads(raw) for raw, in db.execute(
            'SELECT payload FROM events WHERE target_key=? ORDER BY revision DESC LIMIT 50',(key,))]

    def save(self,key,expected,value,template_dependency=None):
        with closing(self.connect()) as db:
            db.execute('BEGIN IMMEDIATE');old=db.execute('SELECT revision FROM reviews WHERE target_key=?',(key,)).fetchone()
            if (old[0] if old else 0)!=expected:
                db.rollback();raise ReviewError(409,'其他窗口已保存此目标；本机草稿保留，请加载服务器版本比较后再保存')
            if template_dependency is not None:
                seed=db.execute('SELECT payload FROM reviews WHERE target_key=?',(template_dependency['target_key'],)).fetchone()
                if not seed or hashlib.sha256(canonical(json.loads(seed[0]))).hexdigest()!=template_dependency['payload_sha256']:
                    db.rollback();raise ReviewError(409,'模板修订已变化，旧建议已停用；本机草稿保留，请重新生成后复核')
            result=dict(value,revision=expected+1,updated_at=datetime.now(timezone.utc).isoformat(timespec='milliseconds'))
            raw=canonical(result).decode()
            db.execute('INSERT INTO reviews VALUES (?,?,?) ON CONFLICT(target_key) DO UPDATE SET revision=excluded.revision,payload=excluded.payload',(key,expected+1,raw))
            db.execute('INSERT INTO events(target_key,revision,payload) VALUES (?,?,?)',(key,expected+1,raw));db.commit()
        return result


class MaskEditor:
    def __init__(self,gallery,directory,access_key):
        self.gallery=gallery;directory=Path(directory).resolve()
        # No test or production editor may turn a source/report/pose directory
        # into its own writable store, including parent/child path collisions.
        project=Path(__file__).resolve().parents[1]
        for protected in (gallery.root,project/'outputs/pallet_pose_human_review_v1',project/'outputs/pallet_dataset_formal_v1',
                          project/'outputs/pallet_structure_human_review_v1',project/'pallet',project/'configs'):
            if directory==protected or directory.is_relative_to(protected) or protected.is_relative_to(directory):
                raise ValueError('Mask review directory must be independent of protected sources and other review stores')
        if not isinstance(access_key,str) or len(access_key.strip())<20:raise ValueError('Missing valid editor access key')
        self.access_key=access_key.strip()
        self.cookie_token=hmac.new(self.access_key.encode(),b'gallery-mask-editor-v1',hashlib.sha256).hexdigest()
        self.proposals=dict(gallery.proposals)
        for key,value in getattr(gallery,'preannotation_proposals',{}).items():
            if key in self.proposals:raise ValueError('Preannotation tasks may not replace counted gallery objects')
            self.proposals[key]=value
        self.pose_database=Path(__file__).resolve().parents[1]/'outputs/pallet_pose_human_review_v1/annotations.sqlite3'
        formal={p['formal_manifest_sha256'] for p in self.proposals.values()}
        if len(formal)!=1:raise ValueError('Gallery mixes formal dataset bindings')
        self.formal_manifest_sha256=formal.pop()
        self.binding=hashlib.sha256(canonical(dict(formal=self.formal_manifest_sha256,
            proposals=gallery.proposals_sha256,editor_version=VERSION))).hexdigest()
        self.store=MaskReviewStore(directory,self.formal_manifest_sha256)

    def proposal(self,key):
        if key not in self.proposals:raise ReviewError(404,'目标不在当前图册中')
        return self.proposals[key]

    def identity(self,key):
        p=self.proposal(key);s=p['source']
        source={k:s[k] for k in ('target_key','frame_id','split','box_index','bbox','size','source_pcd_sha256')}
        source.update(formal_manifest_sha256=self.formal_manifest_sha256,
            image_sha256=self.gallery.assets[f'/images/{key}.png'][2])
        return source

    def source_binding(self,key):return hashlib.sha256(canonical(self.identity(key))).hexdigest()

    def source_reference(self,key):
        proposal=self.proposal(key)
        if proposal.get('schema')==PREANNOTATION_SCHEMA:
            try:return validate_preannotation(proposal,self.formal_manifest_sha256,self.gallery.assets[f'/images/{key}.png'][2])
            except (ValueError,KeyError,TypeError) as error:raise ReviewError(409,'预标注来源已变化或声明不完整，原人工修订和本机草稿保留') from error
        if proposal.get('schema')=='saved_gallery_mask_entry_v1':
            source=proposal.get('human_source',{});binding=source.get('gallery_review',{})
            if (proposal.get('origin')!='mask_gallery_human_revision' or proposal.get('human_edited') is not True or
                    proposal.get('manual_four_point_source') is not True or proposal.get('propagation_seed_eligible') is not False or
                    len(proposal.get('polygon',[]))!=4 or proposal.get('vertex_count')!=4 or 'template' in proposal or
                    source.get('origin')!='mask_gallery_human_revision' or source.get('target_key')!=key or
                    binding.get('target_key')!=key or binding.get('source_binding')!=self.source_binding(key) or
                    binding.get('polygon_sha256')!=hashlib.sha256(canonical(proposal['polygon'])).hexdigest() or
                    any(proposal.get(f) is not False for f in ('human_mask_confirmed','human_pose_confirmed',
                        'ground_truth_eligible','automatic_training_eligible','robot_command_eligible'))):
                raise ReviewError(409,'图库人工四点来源声明不完整，拒绝当作机器建议或传播模板')
            return source
        if proposal.get('original_rectangle_review_only') is True:
            box=proposal['source']['bbox'];x,y,w,h=(box[f] for f in ('x','y','width','height'))
            original=[[x,y],[x+w,y],[x+w,y+h],[x,y+h]]
            if (proposal.get('schema')!='reviewed_original_rectangle_entry_v1' or 'template' in proposal or
                    proposal.get('human_edited') is not False or proposal.get('propagation_seed_eligible') is not False or
                    len(proposal.get('polygon',[]))!=4 or
                    any(proposal.get(f,False) is not False for f in ('human_mask_confirmed','human_pose_confirmed',
                        'ground_truth_eligible','automatic_training_eligible','robot_command_eligible')) or
                    not np.allclose(sorted(proposal['polygon']),sorted(original),rtol=0,atol=1e-5) or
                    proposal.get('human_source',{}).get('target_key')!=key):
                raise ReviewError(409,'原框复核来源声明不完整，拒绝冒充人工修改或传播模板')
            return proposal['human_source']
        if 'template' in proposal:return proposal['template']
        if (proposal.get('manual_four_point_source') is True and proposal.get('propagation_seed_eligible') is False
                and proposal.get('origin')=='original_pose_human_revision' and proposal.get('human_edited') is True
                and len(proposal.get('polygon',[]))==4):
            return proposal['human_source']
        raise ReviewError(409,'人工来源元数据不完整，拒绝套用旧轮廓')

    def proposal_dependency_current(self,key):
        """A newly edited template revokes its unsaved descendants immediately."""
        template=self.source_reference(key)
        if self.proposal(key).get('schema')==PREANNOTATION_SCHEMA:
            return current_preannotation_target(self.pose_database,self.formal_manifest_sha256,template)
        if template.get('origin')=='original_pose_human_revision' or self.proposal(key).get('original_rectangle_review_only') is True:
            return current_pose_source(self.pose_database,self.formal_manifest_sha256,template)
        if template.get('origin')!='mask_gallery_human_revision':return True
        binding=template['gallery_review'];saved=self.store.get(template['target_key'])
        return bool(saved and binding['target_key']==template['target_key'] and
            saved['revision']==binding['revision'] and saved['source_binding']==binding['source_binding'] and
            hashlib.sha256(canonical(saved)).hexdigest()==binding['payload_sha256'] and
            hashlib.sha256(canonical(saved['polygon'])).hexdigest()==binding['polygon_sha256'])

    def detail(self,key):
        p=self.proposal(key);review=self.store.get(key);source_binding=self.source_binding(key)
        if review and review['source_binding']!=source_binding:
            raise ReviewError(409,'原图或目标绑定已变化，旧修订仍保留，不自动套用')
        dependency_current=self.proposal_dependency_current(key)
        if not review and not dependency_current:
            raise ReviewError(409,'模板修订已变化，旧建议已停用；本机草稿保留，请重新生成后复核')
        proposal_id=hashlib.sha256(canonical(p)).hexdigest()
        return dict(target_key=key,source=self.identity(key),class_id=p['class_id'],binding=self.binding,
            source_binding=source_binding,proposal_id=proposal_id,proposal_polygon=p['polygon'],
            template=p.get('template'),human_source=p.get('human_source'),review=review,history=self.store.history(key),
            image_url=f'/images/{key}.png?v={self.gallery.assets[f"/images/{key}.png"][2]}',
            proposal_updated_since_review=bool(review and review['base_proposal_id']!=proposal_id),
            proposal_dependency_stale=not dependency_current,
            saved_pose_manual_source=p.get('origin')=='original_pose_human_revision' and p.get('human_edited') is True,
            saved_gallery_manual_source=p.get('schema')=='saved_gallery_mask_entry_v1',
            saved_pose_review_source=p.get('original_rectangle_review_only') is True,
            original_rectangle_review_only=p.get('original_rectangle_review_only') is True,
            assistant_preannotation_source=p.get('schema')==PREANNOTATION_SCHEMA,
            frame_objects=[dict(target_key=k,bbox=v['source']['bbox']) for k,v in self.proposals.items()
                if v['source']['frame_id']==p['source']['frame_id']])

    def save(self,key,data):
        p=self.proposal(key)
        if (data.get('binding')!=self.binding or data.get('source_binding')!=self.source_binding(key) or
            data.get('proposal_id')!=hashlib.sha256(canonical(p)).hexdigest()):
            raise ReviewError(409,'图册或机器建议版本已变化；原本机草稿保留，请刷新比较')
        expected=data.get('expected_revision')
        if type(expected) is not int or expected<0:raise ReviewError(400,'缺少有效修订版本')
        reviewer,note=data.get('reviewer',''),data.get('note','')
        if not isinstance(reviewer,str) or not isinstance(note,str) or not 1<=len(reviewer.strip())<=80 or len(note)>2000:
            raise ReviewError(400,'请填写标注人（1–80字），备注不超过2000字')
        try:polygon=polygon_value(data.get('polygon'),*p['source']['size'])
        except (ValueError,TypeError) as e:raise ReviewError(400,str(e)) from e
        old=self.store.get(key)
        if old and old['source_binding']!=self.source_binding(key):raise ReviewError(409,'原图绑定变化，拒绝覆盖旧人工修订')
        if old is None and not self.proposal_dependency_current(key):
            raise ReviewError(409,'模板修订已变化，旧建议已停用；本机草稿保留，请重新生成后复核')
        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=data['proposal_id'],proposal_publication=self.gallery.publication_version,
            proposal_polygon=p['polygon'],polygon=polygon,vertex_count=len(polygon),original_vertex_count=p['vertex_count'],
            reviewer=reviewer.strip(),note=note.strip(),event_kind='human_mask_gallery_revision',
            restored_from_revision=restored,status='human_edited_draft_pending_confirmation',
            mask_semantics=p['mask_semantics'],template_provenance=p.get('template'),
            human_source_provenance=p.get('human_source'),
            human_edited=True,human_mask_confirmed=False,human_pose_confirmed=False,
            automatic_training_eligible=False,robot_command_eligible=False,pose=None,
            pose_store_written=False,original_proposal_modified=False)
        if p.get('schema')==PREANNOTATION_SCHEMA:
            value['preannotation_provenance']=dict(proposal_sha256=data['proposal_id'],assistant_draft=p['preannotation'],
                worklist_manifest_sha256=getattr(self.gallery,'preannotation_manifest_sha256',None),assistant_draft_not_human_edit=True)
        reference=self.source_reference(key)
        dependency=reference.get('gallery_review') if old is None and reference.get('origin')=='mask_gallery_human_revision' else None
        return self.store.save(key,expected,value,template_dependency=dependency)

    def export(self,key,kind):
        p=self.proposal(key);review=self.store.get(key)
        if review is None:raise ReviewError(404,'此目标还没有已保存的人工复核修订')
        if review['source_binding']!=self.source_binding(key):raise ReviewError(409,'导出绑定变化，请复核后再导出')
        if kind=='labelme.json':
            value=dict(version='5.0.0',imagePath=f'{key}.png',imageData=None,
                annotation_scope='single_target_mask_review_not_full_frame',other_objects_unchanged=True,
                imageWidth=p['source']['size'][0],imageHeight=p['source']['size'][1],
                flags=dict(human_edited=True,human_confirmed=False),shapes=[dict(label='pallet',shape_type='polygon',
                    points=review['polygon'],group_id=p['source']['box_index'],flags=dict(human_edited=True,human_confirmed=False))],
                mask_gallery_review=review)
            return canonical(value),'application/json; charset=utf-8',f'{key}-r{review["revision"]}.json'
        if kind=='mask.png':
            mask=raster_mask(review['polygon'],*p['source']['size']);stream=io.BytesIO()
            Image.fromarray(mask.astype(np.uint8)*255).save(stream,format='PNG')
            return stream.getvalue(),'image/png',f'{key}-r{review["revision"]}.png'
        raise ReviewError(404,'不支持的导出类型')
