"""Explicit Windows webcam service: loopback only, video only, no disk recording.

Does not call ServiceManager.start(): SIP, auto-proxy, recording and telemetry
remain disabled. Holds the shared leader lock so an embedded service cannot race it.
"""
import argparse
import configparser
from datetime import datetime
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import os
from pathlib import Path
import secrets
import socket
import sqlite3
import subprocess
import sys
import threading
import time

import psutil
import requests

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from scripts.local_server import PYTHON, local_environment, recorded_process as web_process

WORK = ROOT / '.runtime' / 'local-webcam'
SCRIPT = Path(__file__).resolve()
PID_FILE = WORK / 'process.json'
STATUS = WORK / 'status.json'
STOP = WORK / 'stop.request'
STREAM = 'laptop_cam'
DEVICE = 'Integrated Camera'
MARKER = 'Managed by scripts/local_webcam.py; loopback video only'
PORTS = {'http': 10002, 'rtsp': 10554, 'rtmp': 10935}
PUSH_URL = f'rtmp://127.0.0.1:{PORTS["rtmp"]}/live/{STREAM}'


def write_json(path, data):
    temp = path.with_suffix('.tmp')
    temp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding='utf-8')
    os.replace(temp, path)


def make_config(source, api_secret, hook_url):
    config = configparser.ConfigParser(interpolation=None, strict=False)
    config.optionxform = str
    config.read_string(source)
    changes = {
        'general': {'listen_ip': '127.0.0.1', 'check_nvidia_dev': '0', 'enable_ffmpeg_log': '0',
                    'mediaServerId': 'local-webcam', 'wait_add_track_ms': '100', 'maxStreamWaitMS': '3000'},
        'api': {'secret': api_secret, 'apiDebug': '0', 'downloadRoot': str(WORK / 'www'),
                'snapRoot': str(WORK / 'www'), 'defaultSnap': ''},
        'cluster': {'origin_url': ''},
        'http': {'port': str(PORTS['http']), 'sslport': '0', 'rootPath': str(WORK / 'www'),
                 'virtualPath': '', 'dirMenu': '0', 'allow_ip_range': '127.0.0.1', 'allow_cross_domains': '0'},
        'rtmp': {'port': str(PORTS['rtmp']), 'sslport': '0'},
        'rtsp': {'port': str(PORTS['rtsp']), 'sslport': '0', 'rtpTransportType': '0'},
        'rtc': {'port': '0', 'tcpPort': '0'}, 'rtp_proxy': {'port': '0', 'dumpDir': ''},
        'srt': {'port': '0'}, 'shell': {'port': '0'}, 'onvif': {'port': '0'},
        'protocol': {'enable_audio': '0', 'add_mute_audio': '0', 'enable_mp4': '0',
                     'enable_hls': '0', 'enable_hls_fmp4': '0', 'enable_ts': '0',
                     'enable_rtsp': '1', 'enable_rtmp': '1', 'enable_fmp4': '1',
                     'continue_push_ms': '0', 'auto_close': '0',
                     'mp4_save_path': str(WORK / 'www'), 'hls_save_path': str(WORK / 'www')},
        'record': {'enableFmp4': '0'}, 'hls': {'broadcastRecordTs': '0', 'segKeep': '0'},
        # ZLM must never launch another ffmpeg process or save a snapshot here.
        'ffmpeg': {'bin': '', 'cmd': '', 'snap': '', 'log': ''},
    }
    for section, values in changes.items():
        if not config.has_section(section):
            config.add_section(section)
        config[section].update(values)
    if config.has_section('hook'):
        config.remove_section('hook')
    config['hook'] = {'enable': '1', 'on_publish': hook_url, 'timeoutSec': '5', 'retry': '0'}
    return config


def capture_command(ffmpeg):
    return [ffmpeg, '-hide_banner', '-loglevel', 'warning', '-f', 'dshow',
            '-rtbufsize', '32M', '-video_size', '640x480', '-framerate', '15',
            '-i', 'video=' + DEVICE, '-map', '0:v:0', '-an', '-sn', '-dn',
            '-c:v', 'libx264', '-preset', 'ultrafast', '-tune', 'zerolatency',
            '-pix_fmt', 'yuv420p', '-g', '30', '-threads', '2', '-f', 'flv', PUSH_URL]


def allowed_publish(data):
    return (data.get('app') == 'live' and data.get('stream') == STREAM
            and data.get('schema') == 'rtmp' and data.get('ip') == '127.0.0.1')


def hook_server():
    route = '/publish/' + secrets.token_urlsafe(32)

    class Handler(BaseHTTPRequestHandler):
        def log_message(self, *args):
            pass  # Never log the per-run hook token or payload.

        def do_POST(self):
            accepted = False
            try:
                size = int(self.headers.get('Content-Length', '0'))
                if self.path == route and self.client_address[0] == '127.0.0.1' and 0 < size <= 16384:
                    self.connection.settimeout(3)
                    accepted = allowed_publish(json.loads(self.rfile.read(size)))
            except (ValueError, OSError, TypeError):
                pass
            data = {'code': 0 if accepted else -1, 'msg': 'video-only local publisher',
                    'enable_audio': False, 'add_mute_audio': False, 'enable_mp4': False,
                    'enable_hls': False, 'enable_hls_fmp4': False}
            body = json.dumps(data).encode()
            self.send_response(200)
            self.send_header('Content-Type', 'application/json')
            self.send_header('Content-Length', str(len(body)))
            self.end_headers()
            self.wfile.write(body)

    server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)
    threading.Thread(target=server.serve_forever, daemon=True).start()
    return server, f'http://127.0.0.1:{server.server_port}{route}'


def check_connections(processes, allowed_ports):
    listeners = set()
    for proc in processes:
        for conn in proc.connections(kind='inet'):
            if conn.type == socket.SOCK_DGRAM:
                raise RuntimeError('Unexpected UDP socket; stopping webcam')
            if conn.laddr and conn.laddr.ip not in ('127.0.0.1', '::1'):
                raise RuntimeError(f'Non-loopback binding {conn.laddr} ({conn.status}); stopping webcam')
            if conn.raddr and conn.raddr.ip not in ('127.0.0.1', '::1'):
                raise RuntimeError('Non-loopback peer; stopping webcam')
            if conn.status == psutil.CONN_LISTEN:
                if conn.laddr.port not in allowed_ports:
                    raise RuntimeError('Unexpected listener; stopping webcam')
                listeners.add(conn.laddr.port)
    return listeners


def owned_process():
    if not PID_FILE.exists():
        return None
    data = json.loads(PID_FILE.read_text(encoding='utf-8'))
    try:
        proc = psutil.Process(data['pid'])
        if abs(proc.create_time() - data['created']) > .01:
            return None
        args = proc.cmdline()
        if (data['root'] != str(ROOT) or len(args) != 3 or Path(args[0]) != PYTHON
                or Path(args[1]) != SCRIPT or args[2] != 'run'):
            raise RuntimeError('PID ownership mismatch; no process stopped')
        return proc
    except psutil.NoSuchProcess:
        return None


def terminate(child):
    if child and child.poll() is None:
        child.terminate()
        try:
            child.wait(timeout=8)
        except subprocess.TimeoutExpired:
            child.kill()
            child.wait(timeout=5)


def run():
    os.environ.update(local_environment())
    from app.services.lifecycle import ServiceLeaderLock
    lock = ServiceLeaderLock()
    if not lock.acquire():
        raise RuntimeError('Another background-service leader exists; refusing to start')
    media = camera = hook = None
    row = None
    try:
        web = web_process()
        if not web:
            raise RuntimeError('Start the local web server first')
        for conn in psutil.net_connections('inet'):
            # TIME_WAIT sockets left by a terminated ZLM have no owning
            # process (pid 0/None on Windows); only a live owner blocks start.
            if conn.laddr and conn.laddr.port in PORTS.values() and conn.pid:
                raise RuntimeError('Media port occupied; no unrelated process was stopped')
        config_data = json.loads((ROOT / 'config.json').read_text(encoding='utf-8'))
        for key, section in [('mediaHttpPort', 'http'), ('mediaRtspPort', 'rtsp'), ('mediaRtmpPort', 'rtmp')]:
            if int(config_data[key]) != PORTS[section]:
                raise RuntimeError('Configured media ports changed; review local webcam settings first')
        from django.conf import settings
        database = Path(settings.DATABASES['default']['NAME'])
        backup_dir = WORK / ('backup-' + datetime.now().strftime('%Y%m%d-%H%M%S-%f'))
        backup_dir.mkdir()
        with sqlite3.connect(database.as_uri() + '?mode=ro', uri=True) as source:
            with sqlite3.connect(backup_dir / database.name) as target:
                source.backup(target)
        import django
        django.setup()  # Services explicitly disabled; normal existing schema migration only.
        from app.models import StreamModel
        existing = StreamModel.objects.filter(code=STREAM).first()
        if existing and (existing.remark != MARKER or existing.pull_stream_type != 32):
            raise RuntimeError('laptop_cam belongs to another stream; refusing to overwrite')
        from app.utils.Secrets import get_runtime_secret
        api_secret = get_runtime_secret('media_secret')
        exe = (ROOT / config_data['mediaStartPath']).resolve()
        if not exe.is_relative_to(ROOT) or not exe.is_file() or b'listen_ip' not in exe.read_bytes():
            raise RuntimeError('Expected project ZLM binary with listen_ip support')
        template = (ROOT / config_data['mediaStartConfigPath']).read_text(encoding='utf-8', errors='replace')
        (WORK / 'www').mkdir(exist_ok=True)
        hook, hook_url = hook_server()
        ini = WORK / 'zlm.ini'
        with ini.open('w', encoding='utf-8') as handle:
            make_config(template, api_secret, hook_url).write(handle, space_around_delimiters=False)
        with (WORK / 'zlm.log').open('ab') as log:
            media = subprocess.Popen([str(exe), '-c', str(ini), '-l', '3', '-t', '2',
                                      '--log-dir', str(WORK / 'zlm-logs')], cwd=WORK,
                                     stdin=subprocess.DEVNULL, stdout=log, stderr=log,
                                     creationflags=subprocess.CREATE_NO_WINDOW)
        client = requests.Session()
        client.trust_env = False

        def api(method, **params):
            response = client.post(f'http://127.0.0.1:{PORTS["http"]}/index/api/{method}',
                                   data={'secret': api_secret, **params}, timeout=3)
            response.raise_for_status()
            return response.json()

        for _ in range(30):
            if media.poll() is not None:
                raise RuntimeError('ZLM exited; see local-webcam/zlm.log')
            listeners = check_connections([psutil.Process(media.pid)], set(PORTS.values()))
            if listeners == set(PORTS.values()):
                break
            time.sleep(.3)
        else:
            raise RuntimeError('Loopback media listeners not ready')
        if api('getThreadsLoad').get('code') != 0:
            raise RuntimeError('Media API health check failed')
        with (WORK / 'ffmpeg.log').open('ab') as log:
            camera = subprocess.Popen(capture_command(os.environ['MONITOR_FFMPEG']), cwd=WORK,
                                      stdin=subprocess.DEVNULL, stdout=log, stderr=log,
                                      creationflags=subprocess.CREATE_NO_WINDOW)
        for _ in range(40):
            if camera.poll() is not None:
                raise RuntimeError('Camera capture failed; see local-webcam/ffmpeg.log')
            info = api('getMediaInfo', schema='rtmp', vhost='__defaultVhost__', app='live', stream=STREAM)
            if info.get('code') == 0 and info.get('tracks'):
                break
            time.sleep(.5)
        else:
            raise RuntimeError('Camera stream readiness timeout')
        if any(track.get('codec_type') != 0 for track in info['tracks']):
            raise RuntimeError('Unexpected non-video track')
        row, _ = StreamModel.objects.get_or_create(code=STREAM, defaults={
            'user_id': 0, 'sort': 0, 'app': 'live', 'name': STREAM, 'nickname': '笔记本内置摄像头',
            'remark': MARKER, 'pull_stream_type': 32, 'pull_stream_transfer_mode': 0,
            'pull_stream_url': PUSH_URL, 'pull_stream_ip': '127.0.0.1',
            'pull_stream_port': PORTS['rtmp'], 'forward_state': 1, 'is_audio': 0,
            'record_enable': 0, 'state': 0, 'camera_name': DEVICE, 'camera_device_id': 'local-webcam'})
        if row.remark != MARKER:
            raise RuntimeError('Stream ownership changed')
        StreamModel.objects.filter(pk=row.pk).update(forward_state=1, record_enable=0, is_audio=0)
        print('Ready: laptop_cam (Integrated Camera, 640x480/15fps, video only)', flush=True)
        while not STOP.exists():
            if not web.is_running() or media.poll() is not None or camera.poll() is not None:
                raise RuntimeError('Web/camera/media process exited; shutting down capture')
            managed = [psutil.Process(os.getpid()), psutil.Process(media.pid), psutil.Process(camera.pid)]
            listeners = check_connections(managed, {*PORTS.values(), hook.server_port})
            info = api('getMediaInfo', schema='rtmp', vhost='__defaultVhost__', app='live', stream=STREAM)
            if info.get('code') != 0 or any(t.get('codec_type') != 0 for t in info.get('tracks', [])):
                raise RuntimeError('Video stream health check failed')
            if info.get('isRecordingMP4') or info.get('isRecordingHLS'):
                raise RuntimeError('Recording detected; stopping camera')
            write_json(STATUS, {'ready': True, 'stream_id': row.pk, 'stream': STREAM, 'device': DEVICE,
                                'media_pid': media.pid, 'camera_pid': camera.pid,
                                'loopback_ports': sorted(listeners), 'tracks': info['tracks'],
                                'audio': False, 'recording': False, 'sip': False,
                                'checked_at': datetime.now().isoformat(timespec='seconds')})
            time.sleep(2)
    finally:
        terminate(camera)
        terminate(media)
        if hook:
            hook.shutdown()
            hook.server_close()
        if row is not None:
            StreamModel.objects.filter(pk=row.pk, remark=MARKER).update(forward_state=0)
        lock.release()
        write_json(STATUS, {'ready': False, 'stopped_at': datetime.now().isoformat(timespec='seconds')})


def start():
    WORK.mkdir(parents=True, exist_ok=True)
    proc = owned_process()
    if proc:
        print('Webcam process already running:', proc.pid)
        return
    STOP.unlink(missing_ok=True)
    STATUS.unlink(missing_ok=True)
    with (WORK / 'supervisor.log').open('ab') as log:
        child = subprocess.Popen([str(PYTHON), str(SCRIPT), 'run'], cwd=ROOT, env=local_environment(),
                                 stdin=subprocess.DEVNULL, stdout=log, stderr=log,
                                 creationflags=subprocess.CREATE_NO_WINDOW)
    proc = psutil.Process(child.pid)
    write_json(PID_FILE, {'pid': proc.pid, 'created': proc.create_time(), 'root': str(ROOT)})
    for _ in range(60):
        if child.poll() is not None:
            raise RuntimeError('Webcam start failed; inspect .runtime/local-webcam/supervisor.log')
        if STATUS.exists() and json.loads(STATUS.read_text(encoding='utf-8')).get('ready'):
            print('Ready: http://127.0.0.1:10001/stream/index | laptop_cam | video only')
            return
        time.sleep(1)
    STOP.touch()
    raise RuntimeError('Webcam readiness timeout; requested shutdown')


def stop():
    proc = owned_process()
    if not proc:
        print('No owned webcam process running')
        return
    STOP.touch()
    try:
        proc.wait(timeout=20)
    except psutil.TimeoutExpired:
        raise RuntimeError('Graceful stop timed out; inspect owned processes before retrying')
    PID_FILE.unlink(missing_ok=True)
    print('Webcam and local media stopped; web server and saved stream record retained')


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('action', choices=['start', 'stop', 'run', 'status'])
    action = parser.parse_args().action
    if action == 'status':
        print(STATUS.read_text(encoding='utf-8') if STATUS.exists() else 'Not started')
    else:
        {'start': start, 'stop': stop, 'run': run}[action]()