"""Small, authenticated, mobile-first human review service; frozen inputs stay read-only."""
from __future__ import annotations

import argparse
from contextlib import closing
import csv
from datetime import datetime, timezone
import fcntl
from functools import lru_cache
import hashlib
import hmac
from http.cookies import CookieError, SimpleCookie
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import io
import json
import logging
import math
import os
from pathlib import Path
import secrets
import sqlite3
from urllib.parse import parse_qs, urlsplit


PROJECT = Path(__file__).resolve().parents[1]
ASSETS = Path(__file__).with_name('assets')/'structure_review'
DEFAULT_SOURCE = PROJECT/'outputs/pallet_structure_attributes_v1'
DEFAULT_REVIEWS = PROJECT/'outputs/pallet_structure_human_review_v1'
COOKIE = 'pallet_review_session'
CLOSURES = {'chuan': '川字（无下横梁）', 'tian': '田字（有下横梁）'}
MAX_BATCH_SIZE = 9
IMAGE_CODEC_VERSION = 'lossless-v1'
LOG = logging.getLogger('pallet.structure_review')


def json_bytes(value):
    return json.dumps(value, ensure_ascii=False, separators=(',', ':'), allow_nan=False).encode()


def sha256(path):
    h = hashlib.sha256()
    with Path(path).open('rb') as stream:
        for block in iter(lambda: stream.read(1024*1024), b''):
            h.update(block)
    return h.hexdigest()


def accepts_webp(header):
    for item in header.split(','):
        mime, *parameters = item.strip().lower().split(';')
        if mime.strip() != 'image/webp': continue
        quality = 1.
        for parameter in parameters:
            if parameter.strip().startswith('q='):
                try: quality = float(parameter.strip()[2:])
                except ValueError: quality = 0.
        if math.isfinite(quality) and 0 < quality <= 1: return True
    return False


def etag_matches(header, etag):
    return any(tag.strip() == '*' or tag.strip().removeprefix('W/') == etag for tag in header.split(','))


def within(root, name):
    path = (root/name).resolve()
    if not path.is_relative_to(root.resolve()):
        raise ValueError('Asset path escapes its source directory')
    return path


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


def batch_items(data):
    if not isinstance(data, dict) or not isinstance(data.get('items'), list) or not 1 <= len(data['items']) <= MAX_BATCH_SIZE:
        raise ReviewError(400, f'每组须包含1至{MAX_BATCH_SIZE}个目标')
    result, seen = [], set()
    for item in data['items']:
        if not isinstance(item, dict): raise ReviewError(400, '批量目标格式不正确')
        key, revision = item.get('target_key'), item.get('expected_revision')
        if not isinstance(key, str) or not key.isalnum() or key in seen:
            raise ReviewError(400, '批量目标无效或重复')
        if type(revision) is not int or revision < 0:
            raise ReviewError(400, '批量目标缺少有效版本，请刷新')
        seen.add(key); result.append((key, revision))
    return result


class ReviewStore:
    """Each edit and its audit event commit together, with optimistic concurrency."""

    def __init__(self, directory, binding):
        self.directory = Path(directory).resolve()
        self.directory.mkdir(parents=True, exist_ok=True)
        self.path = self.directory/'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, status TEXT NOT NULL,
                    support_leg_count INTEGER, closure_type TEXT,
                    reviewer TEXT NOT NULL, note TEXT NOT NULL,
                    revision INTEGER NOT NULL, updated_at 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));
            ''')
            db.execute('BEGIN IMMEDIATE')
            old = db.execute("SELECT value FROM metadata WHERE key='binding'").fetchone()
            value = json_bytes(binding).decode()
            if old and old[0] != value:
                db.rollback()
                raise ValueError('Review database belongs to different frozen proposals; use another review directory')
            db.execute("INSERT OR IGNORE INTO metadata VALUES ('binding', ?)", (value,))
            db.commit()
            if db.execute('PRAGMA quick_check').fetchone()[0] != 'ok':
                raise ValueError('Review database integrity check failed')
        os.chmod(self.path, 0o600)

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

    def all(self):
        with closing(self.connect()) as db:
            return {r['target_key']: dict(r) for r in db.execute('SELECT * FROM reviews')}

    def get(self, key):
        with closing(self.connect()) as db:
            row = db.execute('SELECT * FROM reviews WHERE target_key=?', (key,)).fetchone()
        return dict(row) if row else {'target_key': key, 'status': 'pending', 'revision': 0,
            'support_leg_count': None, 'closure_type': None, 'reviewer': '', 'note': '', 'updated_at': None}

    @staticmethod
    def review_value(key, data):
        if not isinstance(data, dict):
            raise ReviewError(400, '提交内容必须为JSON对象')
        status, leg, closure = data.get('status'), data.get('support_leg_count'), data.get('closure_type')
        revision = data.get('expected_revision')
        if status not in ('approved', 'deferred', 'pending'):
            raise ReviewError(400, '无效的审核状态')
        if type(revision) is not int or revision < 0:
            raise ReviewError(400, '缺少有效的记录版本，请重新加载')
        if leg is not None and (type(leg) is not int or leg not in (2, 3, 4)):
            raise ReviewError(400, '腿数只能为两腿、三腿、四腿或未知')
        if closure not in (None, 'chuan', 'tian'):
            raise ReviewError(400, '无效的横梁类型')
        if status == 'approved' and (leg is None or closure is None):
            raise ReviewError(400, '确认正确前，请明确腿数和下部横梁；看不清可保存为无法判断')
        reviewer, note = data.get('reviewer', ''), data.get('note', '')
        if not isinstance(reviewer, str) or not 1 <= len(reviewer.strip()) <= 80:
            raise ReviewError(400, '请填写审核人昵称（1–80字）')
        if not isinstance(note, str) or len(note) > 2000:
            raise ReviewError(400, '备注不能超过2000字')
        if status == 'pending':
            leg = closure = None
        return {'target_key': key, 'status': status, 'support_leg_count': leg, 'closure_type': closure,
            'reviewer': reviewer.strip(), 'note': note.strip(), 'revision': revision+1,
            'updated_at': datetime.now(timezone.utc).isoformat(timespec='milliseconds')}

    def commit_values(self, values, preserve_notes=False):
        batch_id = secrets.token_hex(12) if len(values) > 1 else None
        if batch_id:
            for value in values:
                value.update(batch_id=batch_id, batch_size=len(values),
                    batch_target_keys=[v['target_key'] for v in values])
        with closing(self.connect()) as db:
            try:
                db.execute('BEGIN IMMEDIATE')
                # Check every version before writing any member of the group.
                for value in values:
                    old = db.execute('SELECT revision,note FROM reviews WHERE target_key=?', (value['target_key'],)).fetchone()
                    if (old[0] if old else 0) != value['revision']-1:
                        raise ReviewError(409, '该组有目标已在其他页面修改，整组未保存；请刷新后再确认，避免覆盖他人审核')
                    if preserve_notes: value['note'] = old['note'] if old else ''
                for value in values:
                    db.execute('''INSERT INTO reviews(target_key,status,support_leg_count,closure_type,
                        reviewer,note,revision,updated_at) VALUES (:target_key,:status,:support_leg_count,:closure_type,
                        :reviewer,:note,:revision,:updated_at) ON CONFLICT(target_key) DO UPDATE SET
                        status=excluded.status, support_leg_count=excluded.support_leg_count,
                        closure_type=excluded.closure_type, reviewer=excluded.reviewer, note=excluded.note,
                        revision=excluded.revision, updated_at=excluded.updated_at''', value)
                    db.execute('INSERT INTO events(target_key,revision,payload) VALUES(?,?,?)',
                        (value['target_key'], value['revision'], json_bytes(value).decode()))
                db.commit()
            except Exception:
                db.rollback()
                raise
        return values

    def save(self, key, data):
        return self.commit_values([self.review_value(key, data)])[0]

    def save_batch(self, data):
        items = batch_items(data)
        if data.get('note_mode', 'preserve') not in ('preserve', 'replace'):
            raise ReviewError(400, '无效的批量备注方式')
        values = [self.review_value(key, dict(data, expected_revision=revision)) for key, revision in items]
        return self.commit_values(values, preserve_notes=data.get('note_mode', 'preserve') == 'preserve')

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


class ReviewApplication:
    def __init__(self, source, directory, dataset, media):
        self.source, self.dataset, self.media = (Path(p).resolve() for p in (source, dataset, media))
        directory = Path(directory).resolve()
        if any(directory.is_relative_to(p) or p.is_relative_to(directory)
               for p in (self.source, self.dataset, self.media)):
            raise ValueError('Human review storage must be separate from frozen inputs')
        manifest = json.loads((self.source/'output_manifest.json').read_text())
        target_path = self.source/'targets.jsonl'
        self.source_hash = sha256(target_path)
        self.image_version = self.source_hash+'-'+IMAGE_CODEC_VERSION
        if manifest.get('state') != 'complete' or manifest['files'].get('targets.jsonl') != self.source_hash:
            raise ValueError('Structure proposals are incomplete or changed after delivery')
        self.rows = {}
        self.groups = {}
        wanted = ('target_key', 'target_id', 'frame_id', 'bbox', 'integer_bbox', 'image', 'final_class_id',
            'final_class', 'split', 'group_id', 'support_leg_count', 'closure_type', 'structure_label_source',
            'structure_priority_review', 'structure_is_seed', 'structure_visual_rechecked',
            'structure_review_flags', 'structure_visual_recheck', 'structure_projection_evidence')
        with target_path.open() as stream:
            for line in stream:
                full = json.loads(line)
                row = {k: full.get(k) for k in wanted}
                evidence = full['structure_projection_evidence']
                row['structure_projection_evidence'] = {k: evidence.get(k) for k in (
                    'threshold_mask', 'foreground_mask', 'selected_trial', 'flags', 'thresholds', 'otsu_threshold',
                    'leg_consensus', 'closure_consensus', 'attribute_sources', 'projection_plot_source',
                    'pointcloud_fallback_attempted')}
                if evidence.get('pointcloud_evidence'):
                    measured = evidence['pointcloud_evidence']
                    row['structure_projection_evidence']['pointcloud_evidence'] = {
                        'native_mask': measured.get('native_mask'), 'flags': measured.get('flags', [])}
                key = row['target_key']
                if not isinstance(key, str) or not key.isalnum() or key in self.rows:
                    raise ValueError('Invalid or duplicate target identity')
                self.rows[key] = row
                self.groups[row['final_class_id']] = row['final_class']
        self.keys = sorted(self.rows, key=lambda k: (self.rows[k]['final_class_id'], self.rows[k]['target_id']))
        if not self.keys:
            raise ValueError('No structure proposals to review')
        binding = {'schema_version': 1, 'source_targets_sha256': self.source_hash, 'targets': len(self.rows)}
        self.store = ReviewStore(directory, binding)
        key_path = directory/'access_key.txt'
        try:
            with open(key_path, 'x', opener=lambda path, flags: os.open(path, flags, 0o600)) as stream:
                stream.write(secrets.token_urlsafe(18)+'\n')
        except FileExistsError:
            pass
        self.access_key = key_path.read_text().strip()
        if len(self.access_key) < 16:
            raise ValueError('Invalid review access key file')
        self.cookie_token = hmac.new(self.access_key.encode(), b'pallet-human-review-session-v1', hashlib.sha256).hexdigest()

    def row(self, key):
        if key not in self.rows:
            raise ReviewError(404, '目标不存在')
        return self.rows[key]

    def statistics(self, reviews=None):
        reviews = self.store.all() if reviews is None else reviews
        counts = {'total': len(self.rows), 'approved': 0, 'deferred': 0, 'pending': 0, 'corrected': 0}
        for key in self.keys:
            review = reviews.get(key, {})
            status = review.get('status', 'pending')
            counts[status] += 1
            if status == 'approved' and any(review[k] != self.rows[key][k] for k in ('support_leg_count', 'closure_type')):
                counts['corrected'] += 1
        return counts

    def queue(self, params):
        def param(name, default=''):
            return params.get(name, [default])[0]
        state = param('state', 'pending')
        if state not in ('pending', 'approved', 'deferred', 'all'):
            raise ReviewError(400, '无效的队列筛选')
        group, split, legs, closure, priority = (param(k) for k in ('group', 'split', 'legs', 'closure', 'priority'))
        term = param('q').strip().lower()[:200]
        reviews, keys = self.store.all(), []
        for key in self.keys:
            row, review = self.rows[key], reviews.get(key, {})
            status = review.get('status', 'pending')
            leg = review.get('support_leg_count') if status != 'pending' else row['support_leg_count']
            close = review.get('closure_type') if status != 'pending' else row['closure_type']
            if state != 'all' and status != state: continue
            if group and str(row['final_class_id']) != group: continue
            if split and row['split'] != split: continue
            if legs and str(leg or 'unknown') != legs: continue
            if closure and (close or 'unknown') != closure: continue
            if priority == '1' and not row['structure_priority_review']: continue
            if priority == 'seed' and not row['structure_is_seed']: continue
            if term and term not in (key+' '+row['target_id']+' '+row['group_id']).lower(): continue
            keys.append(key)
        return {'keys': keys, 'total': len(keys), 'stats': self.statistics(reviews)}

    def detail(self, key):
        row = self.row(key)
        evidence = row['structure_projection_evidence']
        measured = evidence.get('pointcloud_evidence') or {}
        kinds = ['crop', 'context', 'threshold']
        if evidence.get('foreground_mask'): kinds.append('foreground')
        if measured.get('native_mask'): kinds.append('pointcloud')
        return {'target': {k: v for k, v in row.items() if k != 'structure_projection_evidence'},
            'review': self.store.get(key), 'image_kinds': kinds,
            'evidence': {k: evidence.get(k) for k in ('flags', 'selected_trial', 'thresholds', 'otsu_threshold',
                'leg_consensus', 'closure_consensus', 'attribute_sources', 'projection_plot_source',
                'pointcloud_fallback_attempted')},
            'pointcloud_flags': measured.get('flags', []), 'history': self.store.history(key)}

    def save_batch(self, data):
        items = batch_items(data)
        if data.get('source_targets_sha256') != self.source_hash:
            raise ReviewError(409, '批量确认的数据来源已变化，请刷新页面')
        for key, _ in items: self.row(key)
        reviews = self.store.save_batch(data)
        return {'reviews': reviews, 'batch_id': reviews[0].get('batch_id'), 'stats': self.statistics()}

    def image_pixels(self, key, kind):
        from PIL import Image, ImageDraw
        row = self.row(key)
        evidence = row['structure_projection_evidence']
        if kind in ('crop', 'context'):
            path = within(self.dataset, row['image'])
            with Image.open(path) as original:
                image = original.convert('RGB')
            box = row['bbox']
            if kind == 'crop':
                x, y = math.floor(box['x']), math.floor(box['y'])
                right, bottom = math.ceil(box['x']+box['width']), math.ceil(box['y']+box['height'])
                image = image.crop((max(0, x), max(0, y), min(image.width, right), min(image.height, bottom)))
            else:
                draw = ImageDraw.Draw(image)
                draw.rectangle((box['x'], box['y'], box['x']+box['width'], box['y']+box['height']),
                    outline='#ff5c6d', width=max(1, round(image.width/200)))
            return image, None
        relative = {'threshold': evidence.get('threshold_mask'), 'foreground': evidence.get('foreground_mask'),
            'pointcloud': (evidence.get('pointcloud_evidence') or {}).get('native_mask')}.get(kind)
        if not relative:
            raise ReviewError(404, '该目标没有此类图像证据')
        raw = within(self.source, relative).read_bytes()
        with Image.open(io.BytesIO(raw)) as original:
            alpha = 'A' in original.getbands() or 'transparency' in original.info
            return original.convert('RGBA' if alpha else 'RGB'), raw

    @lru_cache(maxsize=512)
    def image_variants(self, key, kind):
        from PIL import ImageChops, features
        image, original_png = self.image_pixels(key, kind)
        metadata = {name: image.info[name] for name in ('icc_profile', 'exif') if image.info.get(name)}
        if original_png is None:
            output = io.BytesIO(); image.save(output, format='PNG')
            original_png = output.getvalue()
        # Keep every displayed pixel and the native resolution. Grayscale and
        # binary PNG modes remove redundant channels without quantizing values.
        if image.mode == 'RGBA' and image.getchannel('A').getextrema() == (255, 255): image = image.convert('RGB')
        if image.mode == 'RGB' and 'icc_profile' not in metadata:
            red, green, blue = image.split()
            if ImageChops.difference(red, green).getbbox() is None and ImageChops.difference(red, blue).getbbox() is None:
                image = image.convert('L')
                histogram = image.histogram()
                if sum(histogram[1:255]) == 0: image = image.convert('1')
        output = io.BytesIO(); image.save(output, format='PNG', optimize=True, compress_level=9)
        png = output.getvalue()
        if original_png and len(original_png) < len(png): png = original_png
        webp = None
        if features.check('webp') and image.mode != 'RGBA':
            try:
                output = io.BytesIO()
                image.save(output, format='WEBP', lossless=True, method=4, exact=True, **metadata)
                encoded = output.getvalue()
                if len(encoded) < len(png): webp = encoded
            except (OSError, ValueError):
                pass  # Older Pillow/libwebp builds retain the optimized PNG path.
        return {'png': png, 'webp': webp}

    def image(self, key, kind):
        """PNG-compatible, pixel-exact representation for existing integrations."""
        return self.image_variants(key, kind)['png']

    def transfer_image(self, key, kind, webp=False):
        variants = self.image_variants(key, kind)
        if webp and variants['webp'] is not None: return variants['webp'], 'image/webp'
        return variants['png'], 'image/png'

    def export(self, format):
        reviews, records = self.store.all(), []
        for key in self.keys:
            row, review = self.rows[key], reviews.get(key, {})
            status = review.get('status', 'pending')
            records.append({'target_key': key, 'target_id': row['target_id'], 'final_class_id': row['final_class_id'],
                'final_class': row['final_class'], 'split': row['split'], 'group_id': row['group_id'],
                'bbox': row['bbox'], 'proposal_support_leg_count': row['support_leg_count'],
                'proposal_closure_type': row['closure_type'], 'human_review_status': status,
                'human_support_leg_count': review.get('support_leg_count'), 'human_closure_type': review.get('closure_type'),
                'human_confirmed': status == 'approved', 'reviewer': review.get('reviewer', ''),
                'note': review.get('note', ''), 'revision': review.get('revision', 0), 'updated_at': review.get('updated_at'),
                'training_eligible': False, 'source_targets_sha256': self.source_hash})
        if format == 'jsonl':
            return b''.join(json_bytes(r)+b'\n' for r in records)
        if format != 'csv':
            raise ReviewError(400, '只支持CSV或JSONL导出')
        stream = io.StringIO(newline='')
        writer = csv.DictWriter(stream, fieldnames=list(records[0]) if records else ['target_key'])
        writer.writeheader()
        for record in records:
            safe = {}
            for k, v in record.items():
                if isinstance(v, dict): v = json.dumps(v, ensure_ascii=False)
                if isinstance(v, str) and v.lstrip().startswith(('=', '+', '-', '@')): v = "'"+v
                safe[k] = v
            writer.writerow(safe)
        return b'\xef\xbb\xbf'+stream.getvalue().encode()


class ReviewServer(ThreadingHTTPServer):
    daemon_threads = True

    def __init__(self, address, application):
        self.application = application
        super().__init__(address, ReviewHandler)


class ReviewHandler(BaseHTTPRequestHandler):
    server_version = 'PalletReview/1.0'

    @property
    def app(self):
        return self.server.application

    def setup(self):
        super().setup()
        self.connection.settimeout(30)

    def log_message(self, format, *args):
        LOG.info('%s %s %s', self.client_address[0], self.command, urlsplit(self.path).path)

    def authenticated(self):
        try:
            cookie = SimpleCookie(self.headers.get('Cookie', ''))
            token = cookie[COOKIE].value if COOKIE in cookie else ''
            return hmac.compare_digest(token, self.app.cookie_token)
        except (ValueError, TypeError, CookieError):
            return False

    def respond(self, status, body=b'', mime='application/json; charset=utf-8', headers=None):
        headers = dict(headers or {})
        self.send_response(status)
        self.send_header('Content-Type', mime)
        if status != 304: self.send_header('Content-Length', str(len(body)))
        self.send_header('Cache-Control', headers.pop('Cache-Control', 'no-store'))
        self.send_header('X-Content-Type-Options', 'nosniff')
        self.send_header('X-Frame-Options', 'DENY')
        self.send_header('Referrer-Policy', 'no-referrer')
        self.send_header('Content-Security-Policy', "default-src 'self'; script-src 'self'; style-src 'self'; "
            "img-src 'self' blob:; connect-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'")
        for k, v in headers.items(): self.send_header(k, v)
        self.end_headers()
        if self.command != 'HEAD' and status != 304: self.wfile.write(body)

    def send_json(self, data, status=200, headers=None):
        self.respond(status, json_bytes(data), headers=headers)

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

    def do_HEAD(self):
        self.dispatch()

    def do_GET(self):
        self.dispatch()

    def do_POST(self):
        self.dispatch()

    def dispatch(self):
        try:
            self.route()
        except ReviewError as exc:
            self.send_json({'error': exc.message}, exc.status)
        except (BrokenPipeError, ConnectionResetError):
            pass
        except Exception:
            LOG.exception('Review request failed')
            self.send_json({'error': '服务处理失败，未确认保存。请重试；持续失败请查看服务日志。'}, 500)

    def route(self):
        parsed = urlsplit(self.path)
        path, query = parsed.path, parse_qs(parsed.query)
        reading = self.command in ('GET', 'HEAD')
        assets = {'/': ('index.html', 'text/html; charset=utf-8'),
            '/app.css': ('app.css', 'text/css; charset=utf-8'), '/app.js': ('app.js', 'text/javascript; charset=utf-8')}
        if reading and path in assets:
            name, mime = assets[path]
            self.respond(200, (ASSETS/name).read_bytes(), mime)
            return
        if reading and path == '/healthz':
            self.send_json({'status': 'ok'})
            return
        if self.command == 'POST' and path == '/api/login':
            data = self.body()
            key = data.get('key', '')
            if not isinstance(key, str) or not hmac.compare_digest(key.encode(), self.app.access_key.encode()):
                raise ReviewError(401, '访问码不正确')
            secure = '; Secure' if self.headers.get('X-Forwarded-Proto') == 'https' else ''
            self.send_json({'ok': True}, headers={'Set-Cookie':
                f'{COOKIE}={self.app.cookie_token}; Path=/; HttpOnly; SameSite=Strict; Max-Age=2592000{secure}'})
            return
        if not self.authenticated():
            raise ReviewError(401, '请先输入访问码')
        if reading and path == '/api/bootstrap':
            self.send_json({'groups': [{'id': k, 'label': v} for k, v in sorted(self.app.groups.items())],
                'stats': self.app.statistics(), 'source_targets_sha256': self.app.source_hash,
                'max_batch_size': MAX_BATCH_SIZE, 'image_version': self.app.image_version,
                'image_compression': 'pixel-exact adaptive WebP/PNG'})
        elif reading and path == '/api/queue':
            self.send_json(self.app.queue(query))
        elif reading and path.startswith('/api/targets/'):
            self.send_json(self.app.detail(path.removeprefix('/api/targets/')))
        elif self.command == 'POST' and path.startswith('/api/reviews/'):
            key = path.removeprefix('/api/reviews/')
            self.app.row(key)
            self.send_json({'review': self.app.store.save(key, self.body()), 'stats': self.app.statistics()})
        elif self.command == 'POST' and path == '/api/review-batches':
            self.send_json(self.app.save_batch(self.body()))
        elif reading and path.startswith('/media/'):
            parts = path.split('/')
            if len(parts) != 4: raise ReviewError(404, '图像不存在')
            body, mime = self.app.transfer_image(parts[2], parts[3], accepts_webp(self.headers.get('Accept', '')))
            etag = '"'+hashlib.sha256(body).hexdigest()+'"'
            versioned = query.get('v', [''])[0] == self.app.image_version
            headers = {'Vary': 'Accept', 'ETag': etag,
                'Cache-Control': 'private, max-age=86400, immutable' if versioned else 'private, no-cache'}
            # Authentication is checked before conditional responses as well.
            if etag_matches(self.headers.get('If-None-Match', ''), etag):
                self.respond(304, mime=mime, headers=headers)
            else:
                self.respond(200, body, mime, headers)
        elif reading and path == '/api/export':
            format = query.get('format', ['csv'])[0]
            data = self.app.export(format)
            self.respond(200, data, 'text/csv; charset=utf-8' if format == 'csv' else 'application/x-ndjson',
                {'Content-Disposition': f'attachment; filename="pallet-human-review.{format}"'})
        else:
            raise ReviewError(404, '页面或接口不存在')


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--host', default='0.0.0.0')
    parser.add_argument('--port', type=int, default=3389)
    parser.add_argument('--source', type=Path, default=DEFAULT_SOURCE)
    parser.add_argument('--reviews', type=Path, default=DEFAULT_REVIEWS)
    parser.add_argument('--dataset', type=Path)
    parser.add_argument('--media', type=Path, default=PROJECT/'outputs/pallet_target_clustering_v1/media')
    args = parser.parse_args()
    logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
    directory = args.reviews.resolve()
    # Check the storage boundary before creating even a lock file.
    config_path = PROJECT/'configs/active_formal_dataset.json'
    dataset = args.dataset or Path(json.loads(config_path.read_text())['dataset'])
    for protected in (args.source.resolve(), dataset.resolve(), args.media.resolve()):
        if directory.is_relative_to(protected) or protected.is_relative_to(directory):
            raise ValueError('Review directory must not overlap frozen sources')
    directory.mkdir(parents=True, exist_ok=True)
    with (directory/'server.lock').open('a') as lock:
        try:
            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
        except BlockingIOError:
            parser.error('This review directory is already served by another process')
        app = ReviewApplication(args.source, directory, dataset, args.media)
        server = ReviewServer((args.host, args.port), app)
        runtime = {'pid': os.getpid(), 'host': args.host, 'port': server.server_port,
            'started_at': datetime.now(timezone.utc).isoformat(), 'targets': len(app.rows),
            'source_targets_sha256': app.source_hash, 'database': str(app.store.path),
            'access_key_file': str(directory/'access_key.txt')}
        (directory/'runtime.json').write_bytes(json_bytes(runtime)+b'\n')
        LOG.info('Human review ready on %s:%s; %s targets. Access key: %s',
            args.host, server.server_port, len(app.rows), directory/'access_key.txt')
        try:
            server.serve_forever(poll_interval=.5)
        except KeyboardInterrupt:
            pass
        finally:
            server.server_close()


if __name__ == '__main__':
    main()
