"""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

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=gallery.proposals
        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 proposal_dependency_current(self,key):
        """A newly edited template revokes its unsaved descendants immediately."""
        template=self.proposal(key)['template']
        if template.get('origin')=='original_pose_human_revision':
            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['template'],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,
            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['template'],
            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)
        dependency=p['template'].get('gallery_review') if old is None and p['template'].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,'不支持的导出类型')
