"""Explicit-allowlist, read-only public endpoint for the frozen anomaly report."""
import argparse
import base64
import fcntl
import hashlib
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import logging
import os
from pathlib import Path
import re
import signal
import socket
import subprocess
import sys
import threading
import time
from urllib.parse import unquote, urlsplit
from urllib.request import urlopen

PROJECT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PROJECT)); sys.path.insert(0, str(PROJECT/'scripts'))
from pallet.cluster_targets import digest
from pallet.pose_review_geometry import canonical
from serve_structure_review import Child, process_identity, read_json, write_json, timestamp

ROOT = PROJECT/'outputs/pallet_mask_annotation_anomalies_v2'
STATE = PROJECT/'outputs/pallet_mask_anomaly_report_managed_v1'
PORT = 3403
LOCAL = 'http://127.0.0.1:3403'
CLOUDFLARED = Path('/tmp/opencode/pallet_review_tunnel/cloudflared')
BASE_ASSETS = frozenset(('reviewed_findings.html', 'reviewed-font.otf', 'report_zh.html', 'report-font.otf',
    'FONT_LICENSE.txt', 'summary.json', 'class_statistics.json', 'visual_review.json', 'anomalies.csv',
    'all_sources.jsonl', 'training_sources.jsonl'))


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


def asset_names(root):
    cases = read_json(Path(root)/'case_index.json')
    names = set(BASE_ASSETS)
    for case in cases:
        key = case['target_key']; name = case['path']
        require(re.fullmatch('[0-9a-f]{24}', key) and name == f'cases/{key}.png', 'Unsafe report case path')
        names.add(name)
    require(len(cases) == 80 and len(names) == len(BASE_ASSETS)+80, 'Frozen80-case report required')
    return names


def bindings(root):
    root = Path(root).resolve(); result = {}
    for name in sorted(asset_names(root)):
        path = (root/name).resolve()
        require(path.is_relative_to(root) and path.is_file() and not (root/name).is_symlink(), 'Unsafe/missing public report member')
        result[name] = digest(path)
    return result


def configure():
    handoff = read_json(ROOT/'FINAL_HANDOFF.json')
    require(handoff['state'] == 'completed_verified_readonly_diagnosis_not_dataset_correction'
        and handoff['readonly_verification_sha256'] == digest(ROOT/'readonly_verification.json')
        and handoff['summary_sha256'] == digest(ROOT/'summary.json')
        and handoff['visual_review_sha256'] == digest(ROOT/'visual_review.json'), 'Completed anomaly report binding differs')
    value = dict(schema='readonly_mask_anomaly_publication_v1', report_directory=str(ROOT.relative_to(PROJECT)),
        final_handoff_sha256=digest(ROOT/'FINAL_HANDOFF.json'), assets=bindings(ROOT),
        read_only=True, editing_enabled=False, production_annotation_requests_enabled=False,
        no_database_or_raw_event_payloads_served=True, no_global_configuration_changes=True)
    STATE.mkdir(mode=0o700, exist_ok=True); path = STATE/'report_binding.json'
    if path.exists():
        require(read_json(path) == value, 'Do not silently republish changed report bytes')
    else:
        with path.open('xb') as stream:
            stream.write(canonical(value)+b'\n')
        path.chmod(0o600)
    return value


class Report:
    def __init__(self, root, assets):
        self.root = Path(root).resolve(); self.assets = assets
        hashes = []
        for name in ('reviewed_findings.html', 'report_zh.html'):
            for script in re.findall(r'<script>(.*?)</script>', (self.root/name).read_text(), flags=re.S):
                hashes.append("'sha256-"+base64.b64encode(hashlib.sha256(script.encode()).digest()).decode()+"'")
        self.csp = "default-src 'none'; img-src 'self'; font-src 'self'; style-src 'unsafe-inline'; script-src "+(' '.join(hashes) or "'none'")+"; connect-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'"


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

    def respond(self, status, raw, mime='text/plain; charset=utf-8', extra=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.report.csp)
        self.send_header('X-Content-Type-Options', 'nosniff'); self.send_header('Referrer-Policy', 'no-referrer')
        self.send_header('Cache-Control', 'no-cache' if status == 200 else 'no-store')
        for key, value in (extra or {}).items():
            self.send_header(key, value)
        self.end_headers()
        if self.command != 'HEAD':
            try:
                self.wfile.write(raw)
            except (BrokenPipeError, ConnectionResetError):
                pass

    def do_GET(self):
        path = unquote(urlsplit(self.path).path)
        if path == '/healthz':
            return self.respond(200, canonical(dict(status='ok', service='pallet_mask_anomaly_readonly_report',
                read_only=True, editing_enabled=False, report_version='v2', comparison_cases=80, reviewed_cases=16)), 'application/json')
        name = 'reviewed_findings.html' if path == '/' else path[1:]
        expected = self.server.report.assets.get(name)
        if not expected:
            return self.respond(404, b'Not found\n')
        file = (self.server.report.root/name).resolve()
        if not file.is_relative_to(self.server.report.root):
            return self.respond(404, b'Not found\n')
        try:
            raw = file.read_bytes()
        except OSError:
            return self.respond(404, b'Not found\n')
        if hashlib.sha256(raw).hexdigest() != expected:
            return self.respond(503, b'Frozen report bytes changed; explicit verification required\n')
        mime = {'.html': 'text/html; charset=utf-8', '.otf': 'font/otf', '.png': 'image/png',
            '.json': 'application/json; charset=utf-8', '.jsonl': 'application/x-ndjson; charset=utf-8',
            '.csv': 'text/csv; charset=utf-8', '.txt': 'text/plain; charset=utf-8'}[file.suffix]
        return self.respond(200, raw, mime, {'ETag': '"'+expected+'"'})

    do_HEAD = do_GET

    def reject(self):
        self.respond(405, b'Read-only report; editing and saving are disabled\n', extra={'Allow': 'GET, HEAD'})
        self.close_connection = True

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


def app():
    binding = configure(); server = ThreadingHTTPServer(('127.0.0.1', PORT), Handler)
    server.daemon_threads = True; server.report = Report(ROOT, binding['assets'])
    try:
        server.serve_forever()
    finally:
        server.server_close()


def healthy():
    try:
        with urlopen(LOCAL+'/healthz', timeout=3) as response:
            value = json.load(response)
        return value.get('service') == 'pallet_mask_anomaly_readonly_report' and value.get('read_only') is True and value.get('editing_enabled') is False
    except (OSError, ValueError):
        return False


def available():
    with socket.socket() as sock:
        try:
            sock.bind(('127.0.0.1', PORT)); return True
        except OSError:
            return False


def running():
    value = read_json(STATE/'supervisor.json'); pid = value.get('pid')
    return value if type(pid) is int and value.get('process_identity') == process_identity(pid) else None


def supervise():
    configure(); require(CLOUDFLARED.is_file() and available(), 'Missing tunnel or occupied new port; existing services unchanged')
    with (STATE/'supervisor.lock').open('a') as lock:
        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
        logging.basicConfig(level=logging.INFO)
        env = dict(os.environ, OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1', PYTHONDONTWRITEBYTECODE='1')
        child = Child('app', [sys.executable, str(Path(__file__).resolve()), 'app'], STATE, env)
        tunnel = Child('tunnel', [str(CLOUDFLARED), 'tunnel', '--no-autoupdate', '--url', LOCAL, '--protocol', 'http2'], STATE, env)
        stopped = threading.Event(); started = timestamp(); identity = process_identity(os.getpid())
        for sig in (signal.SIGTERM, signal.SIGINT):
            signal.signal(sig, lambda *_: stopped.set())
        def persist(status):
            value = dict(state=status, pid=os.getpid(), process_identity=identity, started_at=started, updated_at=timestamp(),
                app=child.status(), tunnel=tunnel.status(), public_url=tunnel.url, local_url=LOCAL, tunnel_connected=tunnel.connected,
                read_only=True, editing_enabled=False, annotation_writes_enabled=False, child_autorestart=True,
                boot_autostart_configured=False, temporary_url=True, old_services_or_configs_modified=False,
                report_directory=str(ROOT.relative_to(PROJECT)), report_binding_sha256=digest(STATE/'report_binding.json'))
            write_json(STATE/'supervisor.json', value); write_json(STATE/'public_access.json', value)
        persist('starting')
        try:
            while not stopped.is_set():
                changed = child.ensure()
                if tunnel.process is not None or healthy():
                    changed = tunnel.ensure() or changed
                changed = tunnel.read_tunnel_status() or changed
                if changed:
                    persist('connected' if tunnel.connected and healthy() else 'reconnecting')
                stopped.wait(1)
        finally:
            tunnel.stop(); child.stop(); tunnel.connected = False; persist('stopped')


def start(timeout):
    value = running()
    if value:
        print(json.dumps(dict(value, already_running=True))); return
    configure(); require(available(), 'Dedicated report port occupied; no old processes changed')
    with (STATE/'supervisor.log').open('ab') as log:
        process = subprocess.Popen([sys.executable, str(Path(__file__).resolve()), 'run'], cwd=PROJECT,
            stdin=subprocess.DEVNULL, stdout=log, stderr=subprocess.STDOUT, start_new_session=True, close_fds=True)
    deadline = time.monotonic()+timeout
    while time.monotonic() < deadline:
        value = running()
        if value and value['pid'] == process.pid and value.get('tunnel_connected') and healthy():
            print(json.dumps(value)); return
        if process.poll() is not None:
            raise RuntimeError('New report supervisor failed; retain its logs')
        time.sleep(1)
    raise RuntimeError('New report still starting; old service URLs remain intact')


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('command', choices=('start', 'run', 'app', 'status')); parser.add_argument('--timeout', type=int, default=100)
    args = parser.parse_args()
    if args.command == 'start':
        start(args.timeout)
    elif args.command == 'run':
        supervise()
    elif args.command == 'app':
        app()
    else:
        print(json.dumps(dict(supervisor=running(), healthy=healthy())))
