"""Independent gallery and temporary public tunnel; no annotation-service reload."""
import argparse
import fcntl
import json
import logging
import os
from pathlib import Path
import signal
import socket
import subprocess
import sys
import threading
import time
from urllib.request import urlopen

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

STATE=PROJECT/'outputs/pallet_mask_gallery_managed_v1'
CLOUDFLARED=Path('/tmp/opencode/pallet_review_tunnel/cloudflared')
LOCAL='http://127.0.0.1:3393'


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


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


def health():
    try:
        with urlopen(LOCAL+'/healthz',timeout=2) as response:
            return json.load(response).get('service')=='pallet_mask_gallery'
    except (OSError,ValueError):return False


def supervise():
    STATE.mkdir(parents=True,exist_ok=True)
    logging.basicConfig(level=logging.INFO,format='%(asctime)s %(levelname)s %(message)s')
    with (STATE/'supervisor.lock').open('a') as lock:
        fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB)
        if not available():raise SystemExit('3393 is occupied; existing processes left unchanged')
        if not CLOUDFLARED.is_file():raise SystemExit('Cloudflared binary is missing')
        old=read_json(STATE/'public_access.json')
        if old:write_json(STATE/('previous_'+str(time.time_ns())+'.json'),old)
        env=dict(os.environ,OPENBLAS_NUM_THREADS='1',OMP_NUM_THREADS='1',PYTHONUNBUFFERED='1')
        app=Child('app',[sys.executable,'-m','pallet.mask_gallery'],STATE,env)
        tunnel=Child('tunnel',[str(CLOUDFLARED),'tunnel','--no-autoupdate','--url',LOCAL,'--protocol','http2'],STATE,env)
        stopped=threading.Event()
        for sig in (signal.SIGTERM,signal.SIGINT):signal.signal(sig,lambda *_:stopped.set())
        started=timestamp();identity=process_identity(os.getpid())
        def persist(status):
            editing=read_json(PROJECT/'configs/active_mask_gallery.json').get('editing_enabled',False)
            value=dict(state=status,pid=os.getpid(),process_identity=identity,started_at=started,updated_at=timestamp(),
                app=app.status(),tunnel=tunnel.status(),public_url=tunnel.url,tunnel_connected=tunnel.connected,
                local_url=LOCAL,read_only=not editing,authentication_required=False,editing_enabled=editing,
                authentication_required_for_editing=editing,child_autorestart=True,
                boot_autostart_configured=False,temporary_url=True,tunnel_type='cloudflare_quick_tunnel',
                gallery_config='configs/active_mask_gallery.json',
                gallery=read_json(PROJECT/'configs/active_mask_gallery.json').get('directory','outputs/pallet_mask_template_bulk_v2')+'/report_zh.html')
            write_json(STATE/'supervisor.json',value);write_json(STATE/'public_access.json',value)
        persist('starting')
        try:
            while not stopped.is_set():
                changed=app.ensure()
                if tunnel.process is not None or health():changed=tunnel.ensure() or changed
                changed=tunnel.read_tunnel_status() or changed
                if changed:persist('connected' if tunnel.connected and health() else 'reconnecting')
                stopped.wait(1)
        finally:tunnel.stop();app.stop();tunnel.connected=False;persist('stopped')


def start(timeout):
    state=running()
    if state:print(json.dumps(dict(state,already_running=True)));return
    if not available():raise SystemExit('3393 occupied; existing services unchanged')
    STATE.mkdir(parents=True,exist_ok=True)
    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:
        state=running()
        if state and state['pid']==process.pid and state.get('tunnel_connected') and health():
            print(json.dumps(state));return
        if process.poll() is not None:raise SystemExit('Startup failed; see '+str(STATE/'supervisor.log'))
        time.sleep(1)
    raise SystemExit('Still starting; see '+str(STATE/'supervisor.json'))


if __name__=='__main__':
    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('command',choices=['start','run','status','stop'])
    parser.add_argument('--timeout',type=int,default=120);args=parser.parse_args()
    if args.command=='run':supervise()
    elif args.command=='start':start(args.timeout)
    elif args.command=='status':print(json.dumps(dict(supervisor=running(),local_http_healthy=health())))
    elif running():os.kill(running()['pid'],signal.SIGTERM);print('Gallery stop requested; annotation services unchanged')
