"""Authenticated anomaly decisions with visual class references and isolated history.

Decisions are proposals, never direct writes to masks, formal classes or training.
"""
from contextlib import closing
from datetime import datetime, timezone
import hashlib
import hmac
from http.cookies import SimpleCookie, CookieError
from http.server import BaseHTTPRequestHandler
import json
from pathlib import Path
import re
import sqlite3
from urllib.parse import unquote, urlsplit

from .cluster_targets import digest
from .pose_review_geometry import canonical

PROJECT = Path(__file__).resolve().parents[1]
COOKIE = 'pallet_anomaly_review_v1'
FALSE_FLAGS = ('source_labels_changed', 'class_assignments_applied', 'training_dataset_changed',
    'ground_truth_eligible', 'automatic_training_eligible', 'robot_command_eligible', 'propagation_seed_eligible')
CLASS_DECISIONS = ('keep', 'propose_change', 'uncertain')
MASK_DECISIONS = ('acceptable', 'valid_vertex_difference', 'needs_redraw', 'scope_inconsistent', 'uncertain')
VIEW_DECISIONS = ('same_view', 'different_view_same_class', 'uncertain')
REASONS = ('class_mismatch', 'view_variant', 'scope_mismatch', 'vertex_semantics', 'boundary', 'low_visibility', 'no_issue')


def sha(value):
    return hashlib.sha256(canonical(value)).hexdigest()


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


def require(value, message):
    if not value:
        raise ValueError(message)


class Store:
    def __init__(self, directory, package_sha256):
        directory = Path(directory).resolve()
        for protected in (PROJECT/'pallet', PROJECT/'configs', PROJECT/'outputs/pallet_pose_human_review_v1',
            PROJECT/'outputs/pallet_mask_gallery_reviews_v1', PROJECT/'outputs/pallet_mask_nonconforming_reviews_v1',
            PROJECT/'outputs/pallet_mask_dataset_update_v1', PROJECT/'outputs/pallet_mask_annotation_anomalies_v2'):
            require(not (directory == protected or directory.is_relative_to(protected) or protected.is_relative_to(directory)),
                'Anomaly decisions must be isolated from protected sources')
        directory.mkdir(parents=True, mode=0o700, exist_ok=True); self.path = 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,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));''')
            db.execute('BEGIN IMMEDIATE')
            prior = db.execute("SELECT value FROM metadata WHERE key='package_sha256'").fetchone()
            require(not prior or prior[0] == package_sha256, 'Use a new review store for a different frozen package')
            db.execute('INSERT OR IGNORE INTO metadata VALUES (?,?)', ('package_sha256', package_sha256)); db.commit()
            require(db.execute('PRAGMA quick_check').fetchone()[0] == 'ok', 'Anomaly decision store integrity failed')
        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 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 100', (key,))]

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

    def save(self, key, expected, value):
        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, '其它窗口已保存此图；本机草稿保留，请先备份再加载服务器版本')
            value = dict(value, revision=expected+1, updated_at=datetime.now(timezone.utc).isoformat(timespec='milliseconds'))
            raw = canonical(value).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 value


def validate_decision(target, references, data):
    if not isinstance(data, dict):
        raise ReviewError(400, '审核内容必须为JSON对象')
    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 1 <= len(reviewer.strip()) <= 80 or not isinstance(note, str) or len(note) > 2000:
        raise ReviewError(400, '请填写审核人，备注最多2000字')
    disposition = data.get('disposition'); cls = data.get('class_decision'); mask = data.get('mask_decision'); view = data.get('view_decision')
    if disposition not in ('reviewed', 'deferred') or cls not in CLASS_DECISIONS or mask not in MASK_DECISIONS or view not in VIEW_DECISIONS:
        raise ReviewError(400, '请分别选择类别、轮廓范围/点数、观察面结论；看不清可暂缓')
    reasons, viewed = data.get('reasons', []), data.get('reference_keys_viewed', [])
    if not isinstance(reasons, list) or len(reasons) > len(REASONS) or any(not isinstance(v, str) or v not in REASONS for v in reasons) or len(reasons) != len(set(reasons)):
        raise ReviewError(400, '无效的异常原因')
    if 'no_issue' in reasons and len(reasons) > 1:
        raise ReviewError(400, '未见异常不能与其它疑点同时选择')
    if not isinstance(viewed, list) or len(viewed) > 200 or any(not isinstance(k, str) or k not in references for k in viewed):
        raise ReviewError(400, '参考图必须来自本版22类图卡')
    viewed = sorted(set(viewed)); proposed = data.get('suggested_class_id')
    if cls == 'propose_change':
        if type(proposed) is not int or not 1 <= proposed <= 22 or proposed == target['class_id']:
            raise ReviewError(400, '请选择不同于当前类别的候选类别')
        if not note.strip():
            raise ReviewError(400, '建议改类时请说明实际结构/观察面依据，不能只填写编号')
        if not any(references[k]['class_id'] == proposed for k in viewed):
            raise ReviewError(400, '请先展开并查看拟改类别的参考图，再提交建议')
    elif proposed is not None:
        raise ReviewError(400, '未建议改类时不能夹带新类别')
    if disposition == 'reviewed' and cls != 'uncertain' and not any(references[k]['class_id'] == target['class_id'] and k != target['target_key'] for k in viewed):
        raise ReviewError(400, '请先查看一张不同目标的同类参考，不需凭记忆判断22类')
    return dict(disposition=disposition, class_decision=cls, suggested_class_id=proposed,
        mask_decision=mask, view_decision=view, reasons=sorted(reasons), reference_keys_viewed=viewed,
        reviewer=reviewer.strip(), note=note.strip())


class Application:
    def __init__(self, root, reviews, access_key):
        self.root = Path(root).resolve(); self.manifest = json.loads((self.root/'manifest.json').read_text())
        self.package_sha256 = digest(self.root/'manifest.json')
        require(len(access_key.strip()) >= 20, 'Missing review access key')
        self.key = access_key.strip(); self.cookie = hmac.new(self.key.encode(), ('anomaly-review:'+self.package_sha256).encode(), hashlib.sha256).hexdigest()
        require(self.manifest['schema'] == 'human_anomaly_review_package_v1' and self.manifest['automatic_label_application'] is False, 'Wrong anomaly review package')
        require(digest(self.root/'catalog.json') == self.manifest['catalog_sha256'], 'Frozen class atlas/catalog differs')
        self.catalog = json.loads((self.root/'catalog.json').read_text())
        self.targets = self.catalog['targets']; self.references = self.catalog['references']; self.classes = self.catalog['classes']
        require(len(self.classes) == 22 and {c['class_id'] for c in self.classes} == set(range(1, 23)), 'All22 visual class cards required')
        require(len(self.targets) == self.manifest['target_count'] and len(self.targets) == len(set(self.targets)), 'Review target count differs')
        for cls in self.classes:
            require(cls['reference_keys'] and all(k in self.references and self.references[k]['class_id'] == cls['class_id'] for k in cls['reference_keys']), 'Class atlas image references invalid')
        for key, target in self.targets.items():
            require(key == target['target_key'] and target['same_class_reference_keys']
                and all(k != key and self.references[k]['class_id'] == target['class_id'] for k in target['same_class_reference_keys']), 'Self/wrong-class primary references forbidden')
        self.assets = self.manifest['public_assets']
        for name, expected in self.assets.items():
            path = (self.root/name).resolve()
            require(path.is_relative_to(self.root) and not (self.root/name).is_symlink() and digest(path) == expected, 'Frozen anomaly-review public asset differs')
        self.store = Store(reviews, self.package_sha256)
        self.csp = "default-src 'none'; img-src 'self'; font-src 'self'; style-src 'self'; script-src 'self'; connect-src 'self'; base-uri 'none'; form-action 'self'; frame-ancestors 'none'"

    def target(self, key):
        if key not in self.targets:
            raise ReviewError(404, '目标不在本版异常清单中')
        target = json.loads(canonical(self.targets[key]))
        return dict(target=target, subject_sha256=sha(target), package_sha256=self.package_sha256,
            review=self.store.get(key), history=self.store.history(key))

    def save(self, key, data):
        target = self.target(key)['target']
        if not isinstance(data, dict):
            raise ReviewError(400, '审核内容必须为JSON对象')
        if data.get('package_sha256') != self.package_sha256 or data.get('subject_sha256') != sha(target):
            raise ReviewError(409, '审核包或标注来源已变化，本机草稿保留')
        decision = validate_decision(target, self.references, data)
        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, original_class_id=target['class_id'], source_formal_split=target['formal_split'],
            source_payload_sha256=target['source_payload_sha256'], source_polygon_sha256=target['source_polygon_sha256'],
            package_sha256=self.package_sha256, subject_sha256=sha(target),
            event_kind='human_mask_anomaly_assessment_not_applied', status='human_review_proposal_pending_separate_application',
            restored_from_revision=restored, reference_images_rendered_not_proof_of_attention=True,
            **decision, **dict.fromkeys(FALSE_FLAGS, False))
        return self.store.save(key, data['expected_revision'], value)


class Handler(BaseHTTPRequestHandler):
    server_version = 'PalletAnomalyHumanReview/1.0'
    sys_version = ''

    def respond(self, status, raw, mime='application/json; charset=utf-8', headers=None):
        self.send_response(status); self.send_header('Content-Type', mime); self.send_header('Content-Length', str(len(raw)))
        self.send_header('Content-Security-Policy', self.server.app.csp); self.send_header('X-Content-Type-Options', 'nosniff')
        self.send_header('Referrer-Policy', 'no-referrer'); self.send_header('Cache-Control', 'no-store')
        for key, value in (headers or {}).items():
            self.send_header(key, value)
        self.end_headers()
        if self.command != 'HEAD':
            try:
                self.wfile.write(raw)
            except (BrokenPipeError, ConnectionResetError):
                pass

    def json(self, value, status=200, headers=None):
        return self.respond(status, canonical(value), headers=headers)

    def authenticated(self):
        try:
            cookie = SimpleCookie(self.headers.get('Cookie', '')); value = cookie[COOKIE].value if COOKIE in cookie else ''
            return hmac.compare_digest(value, self.server.app.cookie)
        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:
            size = int(self.headers.get('Content-Length', '0'))
            if not 0 < size <= 65536:
                raise ReviewError(413, '请求为空或过大')
            value = json.loads(self.rfile.read(size))
        except (ValueError, UnicodeError) as error:
            raise ReviewError(400, '无效请求') from error
        if not isinstance(value, dict):
            raise ReviewError(400, '请求须为对象')
        return value

    def dispatch(self):
        try:
            self.route()
        except ReviewError as error:
            self.json(dict(error=error.message), error.status)
        except (ValueError, KeyError, TypeError):
            self.json(dict(error='请求或冻结来源无效；本机草稿保留'), 400)
        except Exception:
            import logging
            logging.exception('Isolated anomaly review failed')
            self.json(dict(error='读取或保存失败；本机草稿保留，请重试'), 500)

    do_GET = do_HEAD = do_POST = dispatch

    def route(self):
        app = self.server.app; path = unquote(urlsplit(self.path).path); reading = self.command in ('GET', 'HEAD')
        if path == '/healthz' and reading:
            return self.json(dict(status='ok', service='pallet_mask_anomaly_human_review', targets=len(app.targets),
                classes=22, isolated_decision_store=True, labels_automatically_applied=False))
        if path == '/api/bootstrap' and reading:
            return self.json(dict(authenticated=self.authenticated(), package_sha256=app.package_sha256,
                target_count=len(app.targets), current_model_anomalies=app.manifest['current_model_anomalies'],
                class_count=22, labels_automatically_applied=False))
        if path == '/api/login' and self.command == 'POST':
            key = self.body().get('key', '')
            if not isinstance(key, str) or not hmac.compare_digest(key.encode(), app.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}={app.cookie}; Path=/; HttpOnly; SameSite=Strict; Max-Age=2592000{secure}'})
        if path.startswith('/api/'):
            if not self.authenticated():
                raise ReviewError(401, '审核前请先输入原访问码')
            if path == '/api/logout' and self.command == 'POST':
                self.body(); return self.json(dict(ok=True), headers={'Set-Cookie': f'{COOKIE}=; Path=/; HttpOnly; SameSite=Strict; Max-Age=0'})
            if path == '/api/catalog' and reading:
                return self.json(app.catalog)
            if path == '/api/summary' and reading:
                return self.json(dict(reviews={k: dict(revision=v['revision'], disposition=v['disposition']) for k, v in app.store.all().items()}))
            if path == '/api/export/reviews.json' and reading:
                return self.respond(200, canonical(dict(schema='human_anomaly_decision_export_v1', package_sha256=app.package_sha256,
                    decisions=app.store.all(), labels_applied=False)), headers={'Content-Disposition': 'attachment; filename="anomaly-review-proposals.json"'})
            match = re.fullmatch('/api/targets/([0-9a-f]{24})', path)
            if reading and match:
                return self.json(app.target(match[1]))
            match = re.fullmatch('/api/reviews/([0-9a-f]{24})', path)
            if self.command == 'POST' and match:
                return self.json(dict(review=app.save(match[1], self.body())))
            raise ReviewError(404, '审核接口不存在')
        if not reading:
            return self.respond(405, b'Read-only asset\n', 'text/plain; charset=utf-8', {'Allow': 'GET, HEAD'})
        name = 'index.html' if path == '/' else path[1:]
        expected = app.assets.get(name)
        if not expected:
            return self.respond(404, b'Not found\n', 'text/plain; charset=utf-8')
        file = (app.root/name).resolve()
        if not file.is_relative_to(app.root):
            return self.respond(404, b'Not found\n', 'text/plain; charset=utf-8')
        raw = file.read_bytes()
        if hashlib.sha256(raw).hexdigest() != expected:
            return self.respond(503, b'Frozen asset changed\n', 'text/plain; charset=utf-8')
        mime = {'.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8',
            '.otf': 'font/otf', '.png': 'image/png', '.jpg': 'image/jpeg', '.txt': 'text/plain; charset=utf-8'}[file.suffix]
        return self.respond(200, raw, mime)

    def reject(self):
        return self.respond(405, b'Method not allowed\n', 'text/plain; charset=utf-8', {'Allow': 'GET, HEAD, POST'})

    do_PUT = do_DELETE = do_PATCH = do_OPTIONS = do_TRACE = do_CONNECT = reject
