"""Read-only public gallery with an explicit asset allowlist, never a file browser."""
from __future__ import annotations

import argparse
import base64
import hashlib
import hmac
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
from http.cookies import CookieError,SimpleCookie
import json
import logging
from pathlib import Path
import re
from urllib.parse import unquote,urlsplit

from .cluster_targets import digest
from .mask_gallery_review import MaskEditor,ReviewError,COOKIE,VERSION as EDITOR_VERSION
from .mask_template_requests import load_requests
from .mask_gallery_view import online_page

PROJECT=Path(__file__).resolve().parents[1]
DEFAULT_GALLERY=PROJECT/'outputs/pallet_mask_template_bulk_v2'
SERVICE='pallet_mask_gallery'
ASSETS=Path(__file__).with_name('assets')/'mask_gallery'


class Gallery:
    def __init__(self,directory,review_directory=None,access_key=None,requests_config=None):
        self.root=Path(directory).resolve();self.assets={}
        verified=json.loads((self.root/'verification.json').read_text())
        if verified['state']!='passed' or digest(self.root/'proposals.jsonl')!=verified['proposals_sha256']:
            raise ValueError('Gallery proposals do not match completed verification')
        proposals=[json.loads(s) for s in (self.root/'proposals.jsonl').read_text().splitlines()]
        self.proposals={p['target_key']:p for p in proposals};self.proposals_sha256=digest(self.root/'proposals.jsonl')
        self.editor=None;self.edited_page=None;self.manual_request_count=0;self.request_page=None
        self.preannotation_proposals={};self.preannotation_manifest_sha256=None
        if len(proposals)!=verified['proposals_verified']:raise ValueError('Unexpected gallery size')
        self.count=len(proposals)
        self.publication_version=verified.get('publication_version',1)
        names=['report_zh.html','report-font.otf','FONT_LICENSE.txt']
        for name in verified.get('extra_public_images',[]):
            if name!='vertex2_before_after.png':raise ValueError('Unknown supplemental public image')
            names.append(name)
        for p in proposals:
            key=p['target_key']
            if not re.fullmatch('[0-9a-f]{24}',key):raise ValueError('Invalid target asset key')
            names.extend(f'{folder}/{key}.{ext}' for folder,ext in
                [('cases','png'),('images','png'),('masks','png'),('labelme','json')])
        for name in names:
            path=(self.root/name).resolve()
            if not path.is_relative_to(self.root) or not path.is_file():raise ValueError('Unsafe or missing gallery asset')
            mime={'.html':'text/html; charset=utf-8','.png':'image/png','.json':'application/json; charset=utf-8',
                '.otf':'font/otf','.txt':'text/plain; charset=utf-8'}[path.suffix]
            self.assets['/'+name]=(path,mime,digest(path))
        page=(self.root/'report_zh.html').read_text()
        normalized=online_page(page,self.root,set(self.proposals))
        if normalized!=page:self.edited_page=normalized.encode();page=normalized
        requests=load_requests(requests_config,PROJECT) if requests_config else None
        if requests:
            self.assets.update(requests['assets']);self.manual_request_count=requests['count']
            if requests.get('online_page_normalized'):self.request_page=requests['page'].encode()
            if requests.get('preannotations'):
                if requests['preannotation_parent_proposals_sha256']!=self.proposals_sha256:raise ValueError('Preannotation tasks belong to another verified gallery')
                self.preannotation_proposals=requests['preannotations'];self.preannotation_manifest_sha256=requests['preannotation_manifest_sha256']
                counted_frames={p['source']['frame_id'] for p in proposals}
                if (set(self.preannotation_proposals)&set(self.proposals) or
                        any(p['source']['frame_id'] in counted_frames for p in self.preannotation_proposals.values())):
                    raise ValueError('Preannotation tasks must use different, uncounted images')
                for key in self.preannotation_proposals:
                    self.assets[f'/images/{key}.png']=requests['assets'][f'/template-requests/images/{key}.png']
                self.request_page=requests['page'].encode()
            title=(f'新图已预标注：{requests["count"]} 张待复核（保存前不计覆盖）' if self.preannotation_proposals else
                f'补充人工模板：{requests["completed"]}/{requests["count"]} 张已保存（历史任务清单）' if requests['completed'] else f'补充人工模板：{requests["count"]} 张待描绘图像')
            notice=f'<p id="manualTemplateRequests" style="font-family:GalleryEditorSans,sans-serif"><a href="/template-requests/">{title}</a>（任务清单不计作机器候选）</p>'
            self.edited_page=(page.replace('</html>',notice+'</html>') if '</html>' in page else page+notice).encode()
        scripts=re.findall(r'<script>(.*?)</script>',page,flags=re.S)
        if requests:scripts+=re.findall(r'<script>(.*?)</script>',requests['page'],flags=re.S)
        hashes=['\'sha256-'+base64.b64encode(hashlib.sha256(s.encode()).digest()).decode()+'\'' for s in scripts]
        self.csp="default-src 'none'; img-src 'self'; font-src 'self'; style-src 'unsafe-inline'; script-src "+(' '.join(hashes) or "'none'")+"; base-uri 'none'; form-action 'none'; frame-ancestors 'none'"
        if review_directory is not None:
            self.editor=MaskEditor(self,review_directory,access_key)
            for name,mime in [('editor.js','text/javascript; charset=utf-8'),('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))
            fragment=(ASSETS/'editor.html').read_text()
            if self.edited_page is not None:page=self.edited_page.decode()
            self.edited_page=(page.replace('</html>',fragment+'</html>') if '</html>' in page else page+fragment).encode()
            if self.preannotation_proposals:
                taskpage=self.request_page.decode();self.request_page=(taskpage.replace('</html>',fragment+'</html>') if '</html>' in taskpage else taskpage+fragment).encode()
            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 Handler(BaseHTTPRequestHandler):
    server_version='PalletMaskGallery/1.0'
    sys_version=''

    def do_GET(self):self.dispatch()
    def do_HEAD(self):self.dispatch()
    def do_POST(self):self.dispatch()

    def respond(self,status,raw,mime='text/plain; charset=utf-8',etag=None,headers=None):
        self.send_response(status)
        self.send_header('Content-Type',mime);self.send_header('Content-Length',str(len(raw)))
        self.send_header('X-Content-Type-Options','nosniff')
        self.send_header('Content-Security-Policy',self.server.gallery.csp)
        self.send_header('Referrer-Policy','no-referrer')
        self.send_header('Cache-Control','no-cache' if status==200 and etag else 'no-store')
        if etag:self.send_header('ETag','"'+etag+'"')
        if status==405:self.send_header('Allow','GET, HEAD')
        for name,value in (headers or {}).items():self.send_header(name,value)
        self.end_headers()
        if self.command!='HEAD' and status!=304:
            try:self.wfile.write(raw)
            except (BrokenPipeError,ConnectionResetError):pass

    def json(self,value,status=200,headers=None):self.respond(status,json.dumps(value,allow_nan=False).encode(),'application/json; charset=utf-8',headers=headers)

    def authenticated(self):
        if self.server.gallery.editor is None:return False
        try:
            c=SimpleCookie(self.headers.get('Cookie',''));token=c[COOKIE].value if COOKIE in c else ''
            return hmac.compare_digest(token,self.server.gallery.editor.cookie_token)
        except (CookieError,ValueError,TypeError):return False

    def body(self):
        origin=self.headers.get('Origin')
        if (self.headers.get('X-Review-Request')!='1' or self.headers.get('Sec-Fetch-Site')=='cross-site' or
            origin and (urlsplit(origin).netloc!=self.headers.get('Host') or urlsplit(origin).scheme not in ('http','https'))):
            raise ReviewError(403,'不允许跨站提交，请从图册页面操作')
        if self.headers.get('Content-Type','').split(';')[0]!='application/json':raise ReviewError(415,'需要JSON请求')
        try:length=int(self.headers.get('Content-Length','0'))
        except ValueError:raise ReviewError(400,'无效请求长度')
        if not 0<length<=65536:raise ReviewError(413,'请求为空或过大')
        try:data=json.loads(self.rfile.read(length))
        except (ValueError,UnicodeError):raise ReviewError(400,'无效JSON')
        if not isinstance(data,dict):raise ReviewError(400,'请求须为JSON对象')
        return data

    def dispatch(self):
        try:self.route()
        except ReviewError as e:self.json(dict(error=e.message),e.status)
        except (ValueError,KeyError,TypeError) as e:self.json(dict(error=str(e)),400)
        except (BrokenPipeError,ConnectionResetError):pass
        except Exception:
            logging.exception('Mask gallery request failed');self.json(dict(error='保存或读取失败；请保留本机草稿并重试'),500)

    def route(self):
        path=unquote(urlsplit(self.path).path)
        if path.startswith('/api/review/') and self.server.gallery.editor is not None:
            return self.review_route(path)
        if self.command not in ('GET','HEAD'):return self.reject()
        if path=='/healthz':
            value=dict(status='ok',service=SERVICE,read_only=self.server.gallery.editor is None,targets=self.server.gallery.count,
                publication_version=self.server.gallery.publication_version,editing_enabled=self.server.gallery.editor is not None,
                manual_template_requests=self.server.gallery.manual_request_count,
                editor_version=EDITOR_VERSION if self.server.gallery.editor is not None else None)
            self.respond(200,json.dumps(value).encode(),'application/json');return
        if path=='/':path='/report_zh.html'
        asset=self.server.gallery.assets.get(path)
        if not asset:self.respond(404,b'Not found\n');return
        file,mime,sha=asset
        try:raw=file.read_bytes()
        except OSError:self.respond(404,b'Not found\n');return
        if hashlib.sha256(raw).hexdigest()!=sha:
            self.respond(503,b'Gallery asset changed; publication requires verification\n');return
        if path=='/report_zh.html' and self.server.gallery.edited_page is not None:
            raw=self.server.gallery.edited_page;sha=hashlib.sha256(raw).hexdigest()
        if path in ('/template-requests/','/template-requests/report_zh.html') and self.server.gallery.request_page is not None:
            raw=self.server.gallery.request_page;sha=hashlib.sha256(raw).hexdigest()
        if self.headers.get('If-None-Match')=='"'+sha+'"':
            self.respond(304,b'',mime,sha);return
        self.respond(200,raw,mime,sha)

    def review_route(self,path):
        editor=self.server.gallery.editor;reading=self.command in ('GET','HEAD')
        if reading and path=='/api/review/bootstrap':
            return self.json(dict(editor_version=EDITOR_VERSION,authenticated=self.authenticated(),
                binding=editor.binding,targets=self.server.gallery.count,publication_version=self.server.gallery.publication_version))
        if self.command=='POST' and path=='/api/review/login':
            data=self.body();key=data.get('key')
            if not isinstance(key,str) or not hmac.compare_digest(key.encode(),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'{COOKIE}={editor.cookie_token}; Path=/; HttpOnly; SameSite=Strict; Max-Age=2592000{secure}'})
        if not self.authenticated():raise ReviewError(401,'编辑和保存前请先输入位姿标注访问码')
        if self.command=='POST' and path=='/api/review/logout':
            self.body();return self.json(dict(ok=True),headers={'Set-Cookie':f'{COOKIE}=; Path=/; HttpOnly; SameSite=Strict; Max-Age=0'})
        if reading and path=='/api/review/summary':
            values=editor.store.summary()
            return self.json(dict(reviews={k:dict(revision=v['revision'],reviewer=v['reviewer'],updated_at=v['updated_at']) for k,v in values.items() if k in editor.proposals}))
        match=re.fullmatch(r'/api/review/targets/([0-9a-f]{24})',path)
        if reading and match:return self.json(editor.detail(match[1]))
        match=re.fullmatch(r'/api/review/annotations/([0-9a-f]{24})',path)
        if self.command=='POST' and match:
            value=editor.save(match[1],self.body());return self.json(dict(review=value))
        match=re.fullmatch(r'/api/review/export/([0-9a-f]{24})/(labelme\.json|mask\.png)',path)
        if reading and match:
            raw,mime,name=editor.export(match[1],match[2])
            return self.respond(200,raw,mime,headers={'Content-Disposition':f'attachment; filename="{name}"'})
        raise ReviewError(404,'复核接口不存在')

    def reject(self):self.respond(405,b'Read-only gallery\n');self.close_connection=True
    do_PUT=do_PATCH=do_DELETE=do_OPTIONS=do_TRACE=do_CONNECT=reject


class GalleryServer(ThreadingHTTPServer):
    daemon_threads=True
    def __init__(self,address,gallery):
        self.gallery=gallery;super().__init__(address,Handler)


def active_directory(config=None):
    path=Path(config) if config else PROJECT/'configs/active_mask_gallery.json'
    if not path.exists():return DEFAULT_GALLERY
    value=json.loads(path.read_text());root=(PROJECT/value['directory']).resolve()
    if not root.is_relative_to(PROJECT/'outputs'):raise ValueError('Gallery root is outside outputs')
    for name in ('manifest.json','verification.json'):
        if digest(root/name)!=value[name.removesuffix('.json')+'_sha256']:
            raise ValueError('Active gallery verification hash differs')
    return root


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--directory',type=Path)
    parser.add_argument('--port',type=int,default=3393)
    parser.add_argument('--reviews',type=Path,default=PROJECT/'outputs/pallet_mask_gallery_reviews_v1')
    parser.add_argument('--read-only',action='store_true')
    args=parser.parse_args();access_key=None
    config=PROJECT/'configs/active_mask_gallery.json';settings=json.loads(config.read_text()) if config.exists() else {}
    editing=not args.read_only and settings.get('editing_enabled',False)
    if editing:access_key=(PROJECT/'outputs/pallet_pose_human_review_v1/access_key.txt').read_text().strip()
    gallery=Gallery(args.directory or active_directory(),args.reviews if editing else None,access_key,
        requests_config=PROJECT/'configs/active_mask_template_requests.json')
    server=GalleryServer(('127.0.0.1',args.port),gallery)
    logging.basicConfig(level=logging.INFO);logging.info('Read-only gallery ready on 127.0.0.1:%s',server.server_port)
    try:server.serve_forever()
    except KeyboardInterrupt:pass
    finally:server.server_close()


if __name__=='__main__':main()
