"""Atomic class/polygon/description append-only reviewer for new and existing targets."""
from contextlib import closing
import hashlib
import hmac
import io
import json
from pathlib import Path
from http.cookies import SimpleCookie,CookieError

import numpy as np
from PIL import Image

from .cluster_targets import digest
from .mask_model_training_data import PROJECT,FALSE_FLAGS,read,write,jsonl,sha,require
from .mask_gallery_review import MaskReviewStore,ReviewError
from .mask_gallery import Handler
from .mask_quota_saved_extension import load_formal_evidence
from .pose_review_geometry import canonical,polygon_value,raster_mask
from .pallet_description_data import ROOT,FORMAL_SOURCE,binding_guard
from .pallet_description_simple import POLICY,initial_description,observation_status,install_assets

SETS={name:dict(root=PROJECT/f'outputs/pallet_description_round3_{name}_v1',reviews=PROJECT/f'outputs/pallet_description_round3_{name}_reviews_v1',
    managed=PROJECT/f'outputs/pallet_description_round3_{name}_managed_v1',namespace=f'pallet-description-round3-{name}-v1',port=port) for name,port in (('new',3414),('existing',3415))}
DESCRIPTION_KEYS={'text','legs','beams','material','observation','observation_state'}


def validate_description(value,complete=False):
    if not isinstance(value,dict) or set(value)!=DESCRIPTION_KEYS:raise ReviewError(400,'描述字段不完整；草稿保留')
    if (not isinstance(value['text'],str) or len(value['text'])>2000 or not isinstance(value['observation'],str) or len(value['observation'])>1500
        or type(value['legs']) not in (int,type(None)) or value['legs'] not in (None,2,3,4)
        or type(value['beams']) not in (int,type(None)) or value['beams'] not in (None,1,2)
        or value['material'] not in ('塑料','木质','金属','无法判断') or value['observation_state'] not in ('unreviewed','described','uncertain','normal')):
        raise ReviewError(400,'描述格式无效；请使用有效支腿/横梁数、材质和观察状态')
    return {**value,'text':value['text'].strip(),'observation':value['observation'].strip()}


class JointEditor:
    def __init__(self,gallery,directory,key,namespace,guard):
        directory=Path(directory).resolve();allowed=SETS[gallery.mode]['reviews'].resolve()
        require(directory==allowed or directory.is_relative_to(Path('/tmp/opencode')),'Independent new review database required')
        require(len(key.strip())>=20,'Original credential required');self.gallery=gallery;self.proposals=gallery.proposals;self.binding=gallery.manifest_sha256
        self.access_key=key.strip();self.cookie_token=hmac.new(self.access_key.encode(),namespace.encode(),hashlib.sha256).hexdigest();self.source_guard=guard
        self.store=MaskReviewStore(directory,self.binding)
        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,'No rebinding previous 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)
        return dict(proposal=p,initial_description=initial_description(p),description_policy=POLICY,review=self.store.get(key),history=self.store.history(key),binding=self.binding,source_binding=sha(p),source_current=self.source_guard.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 self.source_guard.current():raise ReviewError(409,'来源有新修订，本机草稿保留；需重新整合版本')
        expected=data.get('expected_revision');reviewer=data.get('reviewer');note=data.get('note','');action=data.get('action');cls=data.get('class_id')
        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,'请填写标注人和有效保存操作')
        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:poly=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(poly)!=info['K']:raise ReviewError(400,f'当前类必须为K{info["K"]}，实际{len(poly)}点；本机草稿保留')
        description=validate_description(data.get('description'),complete=action=='correct')
        description['observation_state']=observation_status(description)
        current_sha=sha([cls,poly]);ack=data.get('description_for')
        if not isinstance(ack,dict) or type(ack.get('class_id')) is not int or ack.get('class_id')!=cls or ack.get('polygon')!=poly:raise ReviewError(409,'描述与类别/轮廓版本不符；请核对后再完成')
        restored=data.get('restored_from_revision')
        if restored is not None and (type(restored)is not int or restored not in {v['revision'] for v 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=poly,vertex_count=len(poly),
            class_K_matches=len(poly)==info['K'],description=description,description_geometry_sha256=current_sha,description_status=('default_normal' if not description['observation'] else 'saved') if action=='correct' else 'draft',
            description_policy=POLICY,observation_status=observation_status(description),description_confirmation_required=False,
            geometry_status='human_reviewed' if action=='correct' else 'imported_previously_completed' if p['geometry_previously_completed'] and cls==p['class_id'] and poly==p['polygon'] else 'draft',
            prior_completed_geometry_preserved=p['geometry_previously_completed'],description_model_sha256=p['description_model_sha256'],
            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_joint_class_keypoints_description_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)
        if not self.source_guard.current():raise ReviewError(409,'保存前来源发生变化，本机草稿保留')
        return self.store.save(key,expected,value)

    def export(self,key,kind):
        p=self.proposal(key);v=self.store.get(key)
        if not v:raise ReviewError(409,'尚未保存本轮人工修订')
        if not self.source_guard.current():raise ReviewError(409,'来源变化；历史保留但不导出旧来源新标签')
        if kind=='mask.png':
            stream=io.BytesIO();Image.fromarray(raster_mask(v['polygon'],*p['source']['size']).astype('uint8')*255).save(stream,format='PNG');return stream.getvalue(),'image/png',key+'.png'
        obj=dict(version=self.gallery.publication_version,imagePath=key+'.png',imageWidth=p['source']['size'][0],imageHeight=p['source']['size'][1],imageData=None,
            shapes=[dict(label=f'Class{v["class_id"]}',points=v['polygon'],shape_type='polygon',flags=FALSE_FLAGS)],description=v['description'],review=v,training_eligible=False)
        return canonical(obj),'application/json; charset=utf-8',key+'.json'


class JointGallery:
    def __init__(self,mode,directory=None,key=None,*,guard=None,presentation=None):
        settings=SETS[mode];self.mode=mode;self.root=settings['root'];m=read(self.root/'manifest.json');seal=read(self.root/'verification.json')
        self.manifest_sha256=digest(self.root/'manifest.json');require(seal['manifest_sha256']==self.manifest_sha256 and seal['state']=='passed_joint_description_source_K_and_no_old_image_reuse','Independent task verification required')
        require(digest(self.root/'proposals.jsonl')==m['proposals_sha256'],'Changed proposals');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 targets');self.assets={}
        mimes={'.html':'text/html; charset=utf-8','.js':'text/javascript; charset=utf-8','.css':'text/css; charset=utf-8','.json':'application/json; charset=utf-8','.jsonl':'application/x-ndjson; charset=utf-8','.csv':'text/csv; charset=utf-8','.png':'image/png','.otf':'font/otf','.txt':'text/plain; charset=utf-8'}
        for name,h in m['public_assets'].items():
            raw=self.root/name;path=raw.resolve();require(path.is_relative_to(self.root) and not raw.is_symlink() and digest(path)==h,'Public asset changed');self.assets['/'+name]=(path,mimes[path.suffix],h)
        self.assets['/report_zh.html']=self.assets['/page.html'];formal,_,_=load_formal_evidence(read(FORMAL_SOURCE))
        for name,item in m['original_images'].items():
            path=(formal/item['formal_relative_image']).resolve();require(path.is_relative_to(formal.resolve()) and digest(path)==item['sha256'],'Original image changed');self.assets['/'+name]=(path,'image/png',item['sha256'])
        self.publication_version=settings['namespace'];self.manual_request_count=0;self.request_page=None;self.edited_page=None
        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.source_guard=guard or binding_guard();require(self.source_guard.current(),'Current source verification required')
        for p in self.proposals.values():
            require(len(p['polygon'])==p['K']==self.classes[str(p['class_id'])]['K'],'Initial classK differs');polygon_value(p['polygon'],*p['source']['size']);validate_description(p['description'])
        self.editor=JointEditor(self,directory or settings['reviews'],key,settings['namespace'],self.source_guard)
        install_assets(self,presentation)

    def close(self):self.source_guard.close()


class JointHandler(Handler):
    def authenticated(self):
        try:
            name='pallet_joint_description_'+self.server.gallery.mode;cookies=SimpleCookie(self.headers.get('Cookie',''));token=cookies[name].value if name in cookies else ''
            return hmac.compare_digest(token,self.server.gallery.editor.cookie_token)
        except (CookieError,ValueError,TypeError):return False

    def route(self):
        from urllib.parse import urlsplit
        if urlsplit(self.path).path=='/healthz' and self.command in ('GET','HEAD'):
            g=self.server.gallery;return self.json(dict(status='ok',publication_version=g.publication_version,targets=g.count,editing_enabled=True,joint_description=True,right_button_pan=True,complete_then_next=True,description_policy=getattr(g,'description_policy',None)))
        return super().route()

    def review_route(self,path):
        reading=self.command in ('GET','HEAD');g=self.server.gallery
        if path=='/api/review/login' and self.command=='POST':
            data=self.body();key=data.get('key')
            if not isinstance(key,str) or not hmac.compare_digest(key.encode(),g.editor.access_key.encode()):raise ReviewError(401,'访问码不正确，请沿用原访问码')
            secure='; Secure' if self.headers.get('X-Forwarded-Proto')=='https' else ''
            return self.json(dict(ok=True),headers={'Set-Cookie':f'pallet_joint_description_{g.mode}={g.editor.cookie_token}; Path=/; HttpOnly; SameSite=Strict; Max-Age=2592000{secure}'})
        if path=='/api/review/logout' and self.command=='POST':
            if not self.authenticated():raise ReviewError(401,'请先登录')
            self.body();return self.json(dict(ok=True),headers={'Set-Cookie':f'pallet_joint_description_{g.mode}=; Path=/; HttpOnly; SameSite=Strict; Max-Age=0'})
        if path in ('/api/review/catalog','/api/review/summary','/api/review/unresolved') and reading:
            if not self.authenticated():raise ReviewError(401,'请沿用原访问码登录')
            if path.endswith('catalog'):return self.json(dict(classes=g.classes,examples=read(g.root/'examples.json'),quotas=read(g.root/'quota_report.json'),summary=read(g.root/'summary.json'),
                description_policy=POLICY,targets=[dict(**{k:p[k] for k in ('target_key','class_id','K','classification')},default_normal=not initial_description(p)['observation'].strip(),geometry_previously_completed=p['geometry_previously_completed']) for p in g.proposals.values()]))
            if path.endswith('summary'):return self.json(dict(reviews={k:{field:v[field] for field in ('revision','reviewer','updated_at','action','class_id','description_status')} for k,v in g.editor.store.summary().items()}))
            return self.json(dict(count=read(g.root/'summary.json')['unresolved_classification_targets'],not_counted_as_fine_class_quota=True,examples=read(g.root/'unresolved_examples.json')))
        return super().review_route(path)
