#!/usr/bin/env python3
"""TiviGrid Recorder — an always-on companion that records scheduled IPTV programmes.

iOS cannot start a live recording while the app is closed, so the TiviGrid app sends timers here.
The recorder opens the provider stream at the scheduled time, writes it to disk (MPEG-TS) and serves
the files back to the app. Runs on anything with Python 3.9+: a Mac, a Windows PC, a NAS, a
Raspberry Pi or a VPS. No third-party packages are needed.

    python3 xtreamtv_recorder.py --data ./recorder-data --port 8765

On first start an access token is generated and printed; enter the address and token in
TiviGrid › Settings › Recording Server, scan the pairing QR code, or open the dashboard at
http://<this computer>:8765/ on the phone and tap "Open in TiviGrid".

    python3 xtreamtv_recorder.py --data ./recorder-data --pairing    # print address, token, link, QR
"""
import argparse
import atexit
import http.client
import json
import os
import re
import secrets
import shutil
import signal
import socket
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.parse
import urllib.request
import uuid
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

VERSION = "1.1"
USER_AGENT = "TiviGrid-Recorder/" + VERSION
CHUNK = 64 * 1024
READ_TIMEOUT = 25  # seconds without data before reconnecting
BONJOUR_TYPE = "_xtreamtv._tcp"  # what the app browses for; TXT record "v=1"
PUBLIC_FIELDS = ("id", "title", "summary", "channel_id", "channel_name", "channel_icon", "program_start", "start",
                 "end", "status", "bytes", "failure", "created", "started_at", "finished_at", "interrupted")


def log(message):
    print(time.strftime("%Y-%m-%d %H:%M:%S"), message, flush=True)


class Store:
    """Recordings persisted as JSON. Every mutation is written atomically."""

    def __init__(self, root):
        self.root = root
        self.media_root = os.path.join(root, "recordings")
        os.makedirs(self.media_root, exist_ok=True)
        self.path = os.path.join(root, "recordings.json")
        self.lock = threading.RLock()
        self.items = {}
        if os.path.exists(self.path):
            with open(self.path, "r", encoding="utf-8") as f:
                for item in json.load(f):
                    self.items[item["id"]] = item

    def save(self):
        with self.lock:
            tmp = self.path + ".tmp"
            with open(tmp, "w", encoding="utf-8") as f:
                json.dump(list(self.items.values()), f, indent=1)
            os.replace(tmp, self.path)

    def get(self, rid):
        with self.lock:
            item = self.items.get(rid)
            return dict(item) if item else None

    def all(self):
        with self.lock:
            return [dict(i) for i in self.items.values()]

    def put(self, item):
        with self.lock:
            self.items[item["id"]] = item
            self.save()

    def update(self, rid, **changes):
        with self.lock:
            item = self.items.get(rid)
            if item is None:
                return None
            item.update(changes)
            self.save()
            return dict(item)

    def remove(self, rid):
        with self.lock:
            self.items.pop(rid, None)
            self.save()
        shutil.rmtree(self.folder(rid), ignore_errors=True)

    def folder(self, rid):
        return os.path.join(self.media_root, rid)

    def media(self, rid):
        return os.path.join(self.folder(rid), "media.ts")

    def index_path(self, rid):
        return os.path.join(self.folder(rid), "index.json")

    def load_index(self, rid):
        try:
            with open(self.index_path(rid), "r", encoding="utf-8") as f:
                return json.load(f)
        except (OSError, ValueError):
            return None

    def save_index(self, rid, segments, complete):
        path = self.index_path(rid)
        if not os.path.isdir(os.path.dirname(path)):
            return
        tmp = path + ".tmp"
        with open(tmp, "w", encoding="utf-8") as f:
            json.dump({"segments": segments, "complete": complete}, f)
        os.replace(tmp, path)


def public(item):
    out = {k: item.get(k) for k in PUBLIC_FIELDS}
    return out



# ----------------------------------------------------------------------------------------------
# HLS indexing: a port of XtreamKit's TSSegmenter. Recordings are stored as one MPEG-TS file and
# served as an HLS playlist of byte ranges cut at keyframes, so AVPlayer can stream and seek them.

class TSSegmenter:
    PACKET = 188
    WRAP = 1 << 33
    CLOCK = 90000
    VIDEO_TYPES = {0x01, 0x02, 0x10, 0x1B, 0x24, 0x42, 0xEA}
    AUDIO_TYPES = {0x03, 0x04, 0x0F, 0x11, 0x81, 0x87}

    def __init__(self, target=6.0):
        self.target = target
        self.segments = []  # [offset, length, duration, discontinuity]
        self.processed = 0
        self.carry = b""
        self.carry_offset = 0
        self.pmt_pid = None
        self.video_pid = None
        self.audio_pid = None
        self.hevc = False
        self.last_pat = -1
        self.seg_start = 0
        self.seg_pts = None
        self.seg_max = 0
        self.last_pts = None
        self.frame = 3600
        self.pending_disc = False
        self.next_disc = False
        self.finished = False

    def feed(self, data):
        if not data or self.finished:
            return
        if self.carry:
            buf = self.carry + data
            base = self.carry_offset
        else:
            buf = data
            base = self.processed
        self.processed += len(data)
        consumed = self._process(buf, base)
        self.carry = bytes(buf[consumed:])
        self.carry_offset = base + consumed

    def mark_discontinuity(self):
        if self.seg_pts is not None:
            self.pending_disc = True

    def finish(self):
        if self.finished:
            return
        self.finished = True
        if self.seg_pts is None:
            return
        length = self.processed - self.seg_start
        duration = (self.seg_max + self.frame) / self.CLOCK
        if length > 0 and duration > 0:
            self.segments.append([self.seg_start, length, duration, self.next_disc])
        self.seg_pts = None

    def _process(self, buf, base):
        n = len(buf)
        size = self.PACKET
        i = 0
        while i + size <= n:
            if buf[i] != 0x47:
                j = i + 1
                found = -1
                while j + size < n:
                    if buf[j] == 0x47 and buf[j + size] == 0x47:
                        found = j
                        break
                    j += 1
                if found < 0:
                    return max(i, n - size)
                i = found
                continue
            b1 = buf[i + 1]
            pid = ((b1 & 0x1F) << 8) | buf[i + 2]
            if pid == 0 or pid == self.pmt_pid or (b1 & 0x40 and pid == (self.video_pid if self.video_pid is not None else self.audio_pid)):
                self._packet(buf[i:i + size], base + i)
            i += size
        return i

    def _packet(self, p, offset):
        pusi = p[1] & 0x40
        pid = ((p[1] & 0x1F) << 8) | p[2]
        afc = (p[3] >> 4) & 3
        start = 4
        rai = False
        if afc & 2:
            af_len = p[4]
            if af_len > 0:
                rai = bool(p[5] & 0x40)
            start = 5 + af_len
        if not afc & 1 or start >= len(p):
            return
        if pid == 0:
            if pusi:
                self.last_pat = offset
                self._pat(p, start)
            return
        if pid == self.pmt_pid:
            if pusi:
                self._pmt(p, start)
            return
        if not pusi:
            return
        pes = self._pes(p, start)
        if pes is None:
            return
        pts, es = pes
        key = (rai or self._keyframe(p, es)) if self.video_pid is not None else True
        self._timing(pts, key, offset)

    def _pat(self, p, s):
        t = s + 1 + p[s]
        if t + 8 >= len(p) or p[t] != 0:
            return
        length = ((p[t + 1] & 0x0F) << 8) | p[t + 2]
        end = min(t + 3 + length - 4, len(p))
        i = t + 8
        while i + 4 <= end:
            program = (p[i] << 8) | p[i + 1]
            if program != 0:
                self.pmt_pid = ((p[i + 2] & 0x1F) << 8) | p[i + 3]
                return
            i += 4

    def _pmt(self, p, s):
        t = s + 1 + p[s]
        if t + 12 >= len(p) or p[t] != 2:
            return
        length = ((p[t + 1] & 0x0F) << 8) | p[t + 2]
        info = ((p[t + 10] & 0x0F) << 8) | p[t + 11]
        end = min(t + 3 + length - 4, len(p))
        i = t + 12 + info
        video = audio = None
        hevc = False
        while i + 5 <= end:
            stype = p[i]
            epid = ((p[i + 1] & 0x1F) << 8) | p[i + 2]
            es_len = ((p[i + 3] & 0x0F) << 8) | p[i + 4]
            if stype in self.VIDEO_TYPES and video is None:
                video, hevc = epid, stype == 0x24
            elif stype in self.AUDIO_TYPES and audio is None:
                audio = epid
            i += 5 + es_len
        if video is not None or audio is not None:
            self.video_pid, self.audio_pid, self.hevc = video, audio, hevc

    @staticmethod
    def _pes(p, s):
        if s + 14 > len(p) or p[s] != 0 or p[s + 1] != 0 or p[s + 2] != 1 or not p[s + 7] & 0x80:
            return None
        pts = (((p[s + 9] >> 1) & 7) << 30) | (p[s + 10] << 22) | ((p[s + 11] >> 1) << 15) | (p[s + 12] << 7) | (p[s + 13] >> 1)
        return pts, s + 9 + p[s + 8]

    def _keyframe(self, p, i):
        n = len(p)
        while i + 3 < n:
            if p[i] == 0 and p[i + 1] == 0 and p[i + 2] == 1:
                h = p[i + 3]
                if self.hevc:
                    t = (h >> 1) & 0x3F
                    if 16 <= t <= 21 or t in (32, 33):
                        return True
                else:
                    if (h & 0x1F) in (5, 7) or h in (0xB3, 0xB8):
                        return True
                i += 3
            else:
                i += 1
        return False

    def _delta(self, a, b):
        d = (a - b) % self.WRAP
        if d > self.WRAP // 2:
            d -= self.WRAP
        return d

    def _cut(self, offset, minimum):
        if minimum <= self.last_pat <= offset and offset - self.last_pat <= 64 * self.PACKET:
            return self.last_pat
        return offset

    def _timing(self, pts, key, offset):
        if self.last_pts is not None:
            step = self._delta(pts, self.last_pts)
            if step < -2 * self.CLOCK or step > 10 * self.CLOCK:
                if self.seg_pts is not None:
                    self.pending_disc = True
            elif 0 < step < self.CLOCK:
                self.frame = step
        self.last_pts = pts
        if self.seg_pts is None:
            if key:
                self.seg_start = self._cut(offset, 0)
                self.seg_pts = pts
                self.seg_max = 0
            return
        d = self._delta(pts, self.seg_pts)
        if not self.pending_disc and d > self.seg_max:
            self.seg_max = d
        if not key:
            return
        if not self.pending_disc and d / self.CLOCK < self.target:
            return
        cut = self._cut(offset, self.seg_start + 1)
        duration = (self.seg_max + self.frame) / self.CLOCK if self.pending_disc else d / self.CLOCK
        if cut > self.seg_start and duration > 0:
            self.segments.append([self.seg_start, cut - self.seg_start, duration, self.next_disc])
            self.next_disc = self.pending_disc
        elif self.pending_disc:
            self.next_disc = True
        self.pending_disc = False
        self.seg_start = cut
        self.seg_pts = pts
        self.seg_max = 0


def index_file(path, target=6.0):
    seg = TSSegmenter(target)
    with open(path, "rb") as f:
        while True:
            chunk = f.read(4 * 1024 * 1024)
            if not chunk:
                break
            seg.feed(chunk)
    seg.finish()
    return seg


def build_playlist(segments, media_uri, complete):
    longest = max((s[2] for s in segments), default=0)
    target = max(1, int(-(-longest // 1))) if complete else max(12, int(-(-longest // 1)))
    lines = ["#EXTM3U", "#EXT-X-VERSION:4", f"#EXT-X-TARGETDURATION:{target}", "#EXT-X-MEDIA-SEQUENCE:0",
             f"#EXT-X-PLAYLIST-TYPE:{'VOD' if complete else 'EVENT'}"]
    for n, (offset, length, duration, disc) in enumerate(segments):
        if disc and n > 0:
            lines.append("#EXT-X-DISCONTINUITY")
        lines.append(f"#EXTINF:{duration:.3f},")
        lines.append(f"#EXT-X-BYTERANGE:{length}@{offset}")
        lines.append(media_uri)
    if complete:
        lines.append("#EXT-X-ENDLIST")
    return "\n".join(lines) + "\n"

# ----------------------------------------------------------------------------------------------
# Recording


class StreamError(Exception):
    pass


def open_url(url, timeout=20):
    request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
    try:
        response = urllib.request.urlopen(request, timeout=timeout)
    except urllib.error.HTTPError as exc:
        raise StreamError(f"HTTP {exc.code}") from exc
    except (urllib.error.URLError, OSError, http.client.HTTPException) as exc:
        raise StreamError(str(getattr(exc, "reason", exc))) from exc
    ctype = (response.headers.get("Content-Type") or "").lower()
    return response, ctype


def stream_urls(item):
    p = item["provider"]
    base = p["server"].rstrip("/")
    user = urllib.parse.quote(p["username"], safe="")
    password = urllib.parse.quote(p["password"], safe="")
    cid = item["channel_id"]
    return f"{base}/live/{user}/{password}/{cid}.ts", f"{base}/live/{user}/{password}/{cid}.m3u8"


class Recorder(threading.Thread):
    def __init__(self, store, rid):
        super().__init__(daemon=True, name=f"rec-{rid[:8]}")
        self.store = store
        self.rid = rid
        self.stop_event = threading.Event()
        self.bytes = 0
        self.last_error = None
        self.segmenter = TSSegmenter()
        self.index_lock = threading.Lock()
        self.last_index_save = 0.0

    def snapshot(self):
        """Segments recorded so far, for a growing (EVENT) playlist."""
        with self.index_lock:
            return [list(seg) for seg in self.segmenter.segments]

    def stop(self):
        self.stop_event.set()

    def finished(self, item):
        return self.stop_event.is_set() or time.time() >= item["end"]

    def run(self):
        item = self.store.get(self.rid)
        path = self.store.media(self.rid)
        os.makedirs(os.path.dirname(path), exist_ok=True)
        self.bytes = os.path.getsize(path) if os.path.exists(path) else 0
        if self.bytes:
            # Resuming after a restart: index what is already on disk, then continue the timeline.
            self.segmenter = index_file(path)
            self.segmenter.finished = False
            self.segmenter.seg_pts = None
            self.segmenter.carry = b""
            self.segmenter.next_disc = True
        formats = [f.lower() for f in item["provider"].get("formats") or []]
        allow_ts = not formats or "ts" in formats
        allow_hls = not formats or "m3u8" in formats
        ts_url, hls_url = stream_urls(item)
        mode = "ts" if allow_ts else "hls"
        failures = 0
        log(f"recording started: {item['title']} ({item['channel_name']}) until {time.ctime(item['end'])}")
        with open(path, "ab") as out:
            while not self.finished(item):
                before = self.bytes
                try:
                    if mode == "ts":
                        self.record_ts(ts_url, out, item)
                    else:
                        self.record_hls(hls_url, out, item)
                except StreamError as exc:
                    self.last_error = str(exc)
                except Exception as exc:  # noqa: BLE001 - never let one recording kill the thread silently
                    self.last_error = f"{type(exc).__name__}: {exc}"
                if self.finished(item):
                    break
                failures = 0 if self.bytes > before else failures + 1
                with self.index_lock:
                    self.segmenter.mark_discontinuity()
                if self.bytes == 0 and failures >= 2 and mode == "ts" and allow_hls:
                    log(f"switching {item['title']} to HLS after: {self.last_error}")
                    mode = "hls"
                    failures = 0
                    continue
                self.store.update(self.rid, bytes=self.bytes)
                self.stop_event.wait(min(10, 1 + failures * 2))
        with self.index_lock:
            self.segmenter.finish()
            segments = [list(seg) for seg in self.segmenter.segments]
        final = self.store.get(self.rid)
        if final is not None:
            self.store.save_index(self.rid, segments, True)
        if final is None:  # deleted while recording
            shutil.rmtree(self.store.folder(self.rid), ignore_errors=True)
            return
        if self.bytes > 0:
            self.store.update(self.rid, status="completed", bytes=self.bytes, finished_at=time.time(), failure=None)
            log(f"recording finished: {item['title']} ({self.bytes / 1e6:.1f} MB)")
        else:
            self.store.update(self.rid, status="failed", finished_at=time.time(),
                              failure=self.last_error or "No data was received from the provider.")
            log(f"recording failed: {item['title']}: {self.last_error}")

    def write(self, out, data):
        out.write(data)
        out.flush()
        with self.index_lock:
            self.segmenter.feed(data)
            if time.time() - self.last_index_save > 15:
                self.last_index_save = time.time()
                self.store.save_index(self.rid, [list(seg) for seg in self.segmenter.segments], False)
        self.bytes += len(data)
        if self.bytes // (20 * 1024 * 1024) != (self.bytes - len(data)) // (20 * 1024 * 1024):
            self.store.update(self.rid, bytes=self.bytes)

    def record_ts(self, url, out, item):
        response, ctype = open_url(url, timeout=READ_TIMEOUT)
        with response:
            if ctype.startswith("text/") or "json" in ctype:
                raise StreamError(f"provider returned {ctype}")
            while not self.finished(item):
                try:
                    data = response.read1(CHUNK) if hasattr(response, "read1") else response.read(CHUNK)
                except (socket.timeout, TimeoutError) as exc:
                    raise StreamError("stream stalled") from exc
                except (OSError, http.client.HTTPException) as exc:
                    raise StreamError(str(exc)) from exc
                if not data:
                    raise StreamError("provider closed the stream")
                self.write(out, data)

    def record_hls(self, url, out, item):
        playlist_url = url
        last_seq = None
        while not self.finished(item):
            response, _ = open_url(playlist_url)
            with response:
                text = response.read().decode("utf-8", "replace")
                final_url = response.geturl()
            if not text.startswith("#EXTM3U"):
                raise StreamError("invalid HLS playlist")
            lines = [l.strip() for l in text.splitlines() if l.strip()]
            if any(l.startswith("#EXT-X-STREAM-INF") for l in lines):
                best, best_bw = None, -1
                for i, line in enumerate(lines):
                    if line.startswith("#EXT-X-STREAM-INF"):
                        m = re.search(r"BANDWIDTH=(\d+)", line)
                        bw = int(m.group(1)) if m else 0
                        nxt = next((l for l in lines[i + 1:] if not l.startswith("#")), None)
                        if nxt and bw > best_bw:
                            best, best_bw = nxt, bw
                if not best:
                    raise StreamError("empty master playlist")
                playlist_url = urllib.parse.urljoin(final_url, best)
                continue
            if any(l.startswith("#EXT-X-MAP") for l in lines):
                raise StreamError("fMP4 HLS is not supported")
            target, seq, segments = 6.0, 0, []
            for line in lines:
                if line.startswith("#EXT-X-TARGETDURATION:"):
                    target = float(line.split(":", 1)[1] or 6)
                elif line.startswith("#EXT-X-MEDIA-SEQUENCE:"):
                    seq = int(line.split(":", 1)[1] or 0)
                elif not line.startswith("#"):
                    segments.append((seq, line))
                    seq += 1
            if last_seq is None:
                fresh = segments[-2:]
            elif segments and segments[-1][0] < last_seq:
                fresh = segments[-2:]  # sequence restarted
            else:
                fresh = [s for s in segments if s[0] > last_seq]
            for number, uri in fresh:
                if self.finished(item):
                    return
                seg_response, _ = open_url(urllib.parse.urljoin(final_url, uri))
                with seg_response:
                    self.write(out, seg_response.read())
                last_seq = number
            self.stop_event.wait(max(1.0, min(target / 2, 5)))


class Scheduler(threading.Thread):
    def __init__(self, store):
        super().__init__(daemon=True, name="scheduler")
        self.store = store
        self.active = {}
        self.indexing = set()
        self.lock = threading.Lock()

    def recover(self):
        """Resume or close recordings that were running when the recorder stopped."""
        now = time.time()
        for item in self.store.all():
            if item["status"] != "recording":
                continue
            if now < item["end"] - 30:
                log(f"resuming interrupted recording: {item['title']}")
                self.store.update(item["id"], status="scheduled", interrupted=True)
            else:
                size = os.path.getsize(self.store.media(item["id"])) if os.path.exists(self.store.media(item["id"])) else 0
                self.store.update(item["id"], status="completed" if size else "failed", bytes=size, interrupted=True,
                                  failure=None if size else "The recorder stopped before any data was saved.")
                if size:
                    self.ensure_index(item["id"])

    def run(self):
        self.recover()
        while True:
            now = time.time()
            for item in self.store.all():
                if item["status"] != "scheduled":
                    continue
                if now >= item["end"]:
                    self.store.update(item["id"], status="failed",
                                      failure="Missed: the recorder was not running at the scheduled time.")
                elif now >= item["start"]:
                    self.start_recording(item["id"])
            with self.lock:
                for rid in [r for r, t in self.active.items() if not t.is_alive()]:
                    del self.active[rid]
            time.sleep(1)

    def start_recording(self, rid):
        with self.lock:
            if rid in self.active:
                return
            self.store.update(rid, status="recording", started_at=time.time())
            recorder = Recorder(self.store, rid)
            self.active[rid] = recorder
            recorder.start()

    def stop_recording(self, rid):
        with self.lock:
            recorder = self.active.get(rid)
        if recorder:
            recorder.stop()
            return True
        return False

    def live_segments(self, rid):
        with self.lock:
            recorder = self.active.get(rid)
        if recorder is None or recorder.segmenter.finished or not recorder.is_alive():
            return None
        return recorder.snapshot()

    def ensure_index(self, rid):
        """Builds a missing index in the background (e.g. for a recording interrupted by a restart)."""
        with self.lock:
            if rid in self.indexing:
                return
            self.indexing.add(rid)

        def work():
            try:
                seg = index_file(self.store.media(rid))
                self.store.save_index(rid, seg.segments, True)
            except OSError as exc:
                log(f"indexing failed for {rid}: {exc}")
            finally:
                with self.lock:
                    self.indexing.discard(rid)

        threading.Thread(target=work, daemon=True, name=f"index-{rid[:8]}").start()

    def live_bytes(self, rid):
        with self.lock:
            recorder = self.active.get(rid)
        return recorder.bytes if recorder else None


# ----------------------------------------------------------------------------------------------
# HTTP API


def content_disposition(title):
    """A download header that works for any title: HTTP headers must be Latin-1, so non-Latin titles
    (Hebrew, Arabic…) go in the RFC 5987 `filename*` form with a plain ASCII fallback."""
    name = re.sub(r"[^\w\- ]+", "", title).strip() or "recording"
    ascii_name = re.sub(r"[^A-Za-z0-9\- ]+", "", name).strip(" -") or "recording"
    return f"attachment; filename=\"{ascii_name}.ts\"; filename*=UTF-8''{urllib.parse.quote(name + '.ts')}"


class RecorderHTTPServer(ThreadingHTTPServer):
    daemon_threads = True

    def handle_error(self, request, client_address):
        # Phones drop connections all the time (app in the background, network change): not an error.
        if isinstance(sys.exc_info()[1], (ConnectionResetError, BrokenPipeError, TimeoutError)):
            return
        super().handle_error(request, client_address)


def make_handler(store, scheduler, token, public_url=None):
    class Handler(BaseHTTPRequestHandler):
        protocol_version = "HTTP/1.1"
        server_version = "XtreamTVRecorder/" + VERSION

        def log_message(self, fmt, *args):
            if os.environ.get("RECORDER_VERBOSE"):
                sys.stderr.write("%s - %s\n" % (self.address_string(), fmt % args))

        # -- helpers ----------------------------------------------------------------------------
        def send_json(self, obj, status=200):
            body = json.dumps(obj).encode()
            self.send_response(status)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            if self.command != "HEAD":
                self.wfile.write(body)

        def error(self, status, message):
            self.send_json({"error": message}, status)

        def send_dashboard(self):
            """The web dashboard. A static page with no data in it; it asks for the token and then
            calls the API like the app does, so it is served without authentication."""
            body = DASHBOARD_HTML.encode()
            self.send_response(200)
            self.send_header("Content-Type", "text/html; charset=utf-8")
            self.send_header("Content-Length", str(len(body)))
            self.send_header("Cache-Control", "no-cache")
            self.send_header("X-Frame-Options", "DENY")
            self.send_header("Referrer-Policy", "no-referrer")
            self.end_headers()
            if self.command != "HEAD":
                self.wfile.write(body)

        def authorized(self, query):
            header = self.headers.get("Authorization", "")
            supplied = header[7:] if header.startswith("Bearer ") else query.get("token", "")
            return secrets.compare_digest(supplied, token)

        def read_json(self):
            length = int(self.headers.get("Content-Length") or 0)
            if length <= 0 or length > 1_000_000:
                raise ValueError("missing or oversized body")
            return json.loads(self.rfile.read(length))

        def route(self):
            url = urllib.parse.urlparse(self.path)
            query = {k: v[0] for k, v in urllib.parse.parse_qs(url.query).items()}
            parts = [p for p in url.path.split("/") if p]
            return parts, query

        # -- verbs ------------------------------------------------------------------------------
        def do_HEAD(self):
            self.do_GET()

        def do_GET(self):
            parts, query = self.route()
            if parts == ["api", "ping"]:
                return self.send_json({"ok": True, "version": VERSION})
            if parts in ([], ["dashboard"]):
                return self.send_dashboard()
            if not self.authorized(query):
                return self.error(401, "invalid token")
            if parts == ["api", "pairing"]:
                address = server_address(self.server.server_address[1], public_url, self.headers.get("Host"))
                info = pairing_info(address, token)
                info["qr"] = ["".join("1" if dark else "0" for dark in row) for row in qr_matrix(info["link"])]
                return self.send_json(info)
            if parts == ["api", "info"]:
                usage = shutil.disk_usage(store.root)
                return self.send_json({"name": socket.gethostname(), "version": VERSION, "time": time.time(),
                                       "free_bytes": usage.free, "total_bytes": usage.total})
            if parts == ["api", "recordings"]:
                items = []
                for item in sorted(store.all(), key=lambda i: i["start"]):
                    live = scheduler.live_bytes(item["id"])
                    if live is not None:
                        item["bytes"] = live
                    out = public(item)
                    segments = scheduler.live_segments(item["id"])
                    if segments is None:
                        index = store.load_index(item["id"])
                        segments = index["segments"] if index else []
                    out["duration"] = round(sum(seg[2] for seg in segments), 1)
                    items.append(out)
                return self.send_json(items)
            if len(parts) == 4 and parts[:2] == ["api", "recordings"] and parts[3] == "media.ts":
                return self.send_media(parts[2])
            if len(parts) == 4 and parts[:2] == ["api", "recordings"] and parts[3] == "index.m3u8":
                return self.send_playlist(parts[2], query.get("token", ""))
            return self.error(404, "not found")

        def do_POST(self):
            parts, query = self.route()
            if not self.authorized(query):
                return self.error(401, "invalid token")
            if parts == ["api", "recordings"]:
                try:
                    return self.create(self.read_json())
                except (ValueError, KeyError, TypeError) as exc:
                    return self.error(400, f"invalid request: {exc}")
            if len(parts) == 4 and parts[:2] == ["api", "recordings"] and parts[3] == "stop":
                item = store.get(parts[2])
                if not item:
                    return self.error(404, "not found")
                if item["status"] == "recording":
                    scheduler.stop_recording(item["id"])
                    return self.send_json(public(item))
                return self.error(409, "not recording")
            return self.error(404, "not found")

        def do_DELETE(self):
            parts, query = self.route()
            if not self.authorized(query):
                return self.error(401, "invalid token")
            if len(parts) == 3 and parts[:2] == ["api", "recordings"]:
                item = store.get(parts[2])
                if not item:
                    return self.error(404, "not found")
                scheduler.stop_recording(item["id"])
                store.remove(item["id"])
                return self.send_json({"deleted": item["id"]})
            return self.error(404, "not found")

        # -- actions ----------------------------------------------------------------------------
        def create(self, body):
            now = time.time()
            start, end = float(body["start"]), float(body["end"])
            if end <= start:
                raise ValueError("end must be after start")
            if end <= now:
                raise ValueError("end is in the past")
            if end - start > 12 * 3600:
                raise ValueError("recordings are limited to 12 hours")
            provider = body["provider"]
            for key in ("server", "username", "password"):
                if not str(provider.get(key, "")).strip():
                    raise ValueError(f"provider.{key} is required")
            item = {
                "id": str(uuid.uuid4()),
                "title": str(body.get("title") or body.get("channel_name") or "Recording")[:200],
                "summary": str(body.get("summary") or "")[:2000],
                "channel_id": int(body["channel_id"]),
                "channel_name": str(body.get("channel_name") or "")[:200],
                "channel_icon": body.get("channel_icon"),
                "program_start": body.get("program_start"),
                "start": max(start, now) if start < now else start,
                "end": end,
                "provider": {"server": str(provider["server"]).rstrip("/"), "username": str(provider["username"]),
                             "password": str(provider["password"]),
                             "formats": [str(f) for f in provider.get("formats") or []],
                             "max_connections": provider.get("max_connections")},
                "status": "scheduled",
                "bytes": 0,
                "failure": None,
                "created": now,
                "started_at": None,
                "finished_at": None,
                "interrupted": False,
            }
            # Warn about overlaps: providers often allow a single connection.
            overlapping = [i for i in store.all()
                           if i["status"] in ("scheduled", "recording") and i["start"] < end and start < i["end"]
                           and i["provider"]["server"] == item["provider"]["server"]
                           and i["provider"]["username"] == item["provider"]["username"]]
            store.put(item)
            if item["start"] <= now:
                scheduler.start_recording(item["id"])
            response = public(store.get(item["id"]))
            limit = provider.get("max_connections")
            if overlapping and isinstance(limit, int) and len(overlapping) + 1 > limit:
                response["warning"] = (f"This overlaps {len(overlapping)} other recording(s) and your provider allows "
                                       f"{limit} connection(s); one of them may fail.")
            log(f"timer added: {item['title']} {time.ctime(item['start'])} – {time.ctime(item['end'])}")
            return self.send_json(response, 201)

        def send_playlist(self, rid, query_token):
            """HLS playlist for streaming a recording (growing while it is still being recorded)."""
            item = store.get(rid)
            if not item or not os.path.exists(store.media(rid)):
                return self.error(404, "no media")
            live = scheduler.live_segments(rid)
            if live is not None:
                segments, complete = live, False
            else:
                index = store.load_index(rid)
                if not index or not index.get("complete"):
                    scheduler.ensure_index(rid)
                    self.send_response(503)
                    self.send_header("Retry-After", "5")
                    self.send_header("Content-Length", "0")
                    self.end_headers()
                    return
                segments, complete = index["segments"], True
            # Media requests carry the token in the query string because AVPlayer can't add headers.
            uri = "media.ts?token=" + urllib.parse.quote(query_token or token, safe="")
            body = build_playlist(segments, uri, complete).encode()
            self.send_response(200)
            self.send_header("Content-Type", "application/vnd.apple.mpegurl")
            self.send_header("Cache-Control", "no-cache")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            if self.command != "HEAD":
                self.wfile.write(body)

        def send_media(self, rid):
            item = store.get(rid)
            path = store.media(rid)
            if not item or not os.path.exists(path):
                return self.error(404, "no media")
            size = os.path.getsize(path)
            start, end = 0, size - 1
            status = 200
            header = self.headers.get("Range")
            if header and header.startswith("bytes="):
                spec = header[6:].split(",")[0].strip()
                a, _, b = spec.partition("-")
                try:
                    if a == "":
                        start = max(0, size - int(b))
                    else:
                        start = int(a)
                        if b:
                            end = min(int(b), size - 1)
                except ValueError:
                    return self.error(400, "bad range")
                if start >= size:
                    self.send_response(416)
                    self.send_header("Content-Range", f"bytes */{size}")
                    self.send_header("Content-Length", "0")
                    self.end_headers()
                    return
                status = 206
            length = max(0, end - start + 1)
            self.send_response(status)
            self.send_header("Content-Type", "video/mp2t")
            self.send_header("Accept-Ranges", "bytes")
            self.send_header("Content-Length", str(length))
            if status == 206:
                self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
            self.send_header("Content-Disposition", content_disposition(item["title"]))
            self.end_headers()
            if self.command == "HEAD":
                return
            try:
                with open(path, "rb") as f:
                    f.seek(start)
                    remaining = length
                    while remaining > 0:
                        data = f.read(min(1024 * 1024, remaining))
                        if not data:
                            break
                        self.wfile.write(data)
                        remaining -= len(data)
            except (BrokenPipeError, ConnectionResetError):
                pass

    return Handler


def load_token(root, override):
    config_path = os.path.join(root, "config.json")
    config = {}
    if os.path.exists(config_path):
        with open(config_path, "r", encoding="utf-8") as f:
            config = json.load(f)
    if override:
        config["token"] = override
    if not config.get("token"):
        config["token"] = secrets.token_urlsafe(18)
    with open(config_path, "w", encoding="utf-8") as f:
        json.dump(config, f)
    try:
        os.chmod(config_path, 0o600)
    except OSError:
        pass
    return config["token"]


# ----------------------------------------------------------------------------------------------
# Network address, pairing link and Bonjour


def lan_address():
    """The address other devices on the network reach this computer at. Connecting a UDP socket
    sends nothing; it only makes the OS pick the outgoing interface. Falls back to the hostname's
    address, then to loopback when the computer is offline."""
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        try:
            s.connect(("8.8.8.8", 80))
            address = s.getsockname()[0]
        finally:
            s.close()
        if address and not address.startswith(("127.", "0.")):
            return address
    except OSError:
        pass
    try:
        address = socket.gethostbyname(socket.gethostname())
        if address and not address.startswith(("127.", "0.")):
            return address
    except OSError:
        pass
    return "127.0.0.1"


def local_addresses():
    """Every IPv4 address of this computer worth showing (the LAN one first), e.g. also a Tailscale one."""
    addresses = [lan_address()]
    try:
        for info in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET):
            address = info[4][0]
            if not address.startswith(("127.", "0.", "169.254.")) and address not in addresses:
                addresses.append(address)
    except OSError:
        pass
    if len(addresses) > 1 and addresses[0] == "127.0.0.1":
        addresses.pop(0)
    return addresses


def is_loopback_host(host):
    return host in ("localhost", "0.0.0.0", "::1", "::") or host.startswith("127.") or host.endswith(".localhost")


def pairing_link(address, token):
    """The contract with the app: xtreamtv://recorder?address=<server URL>&token=<access token>."""
    query = urllib.parse.urlencode({"address": address, "token": token}, quote_via=urllib.parse.quote)
    return "xtreamtv://recorder?" + query


def pairing_info(address, token):
    return {"address": address, "token": token, "link": pairing_link(address, token)}


def server_address(port, public_url=None, host_header=None):
    """The base URL to hand to the phone: --public-url if set; else the host the request came in on
    (whoever opened the dashboard reached us there); else this computer's LAN address."""
    if public_url:
        return public_url.rstrip("/")
    if host_header:
        try:
            hostname = urllib.parse.urlsplit("//" + host_header).hostname
        except ValueError:
            hostname = None
        if hostname and not is_loopback_host(hostname):
            return "http://" + host_header
    return f"http://{lan_address()}:{port}"


class Bonjour:
    """Advertises the recorder on the local network (service type _xtreamtv._tcp, TXT v=1) so the app
    can find it without typing an address. Best effort: uses the system's `dns-sd` (macOS) or
    `avahi-publish` (Linux, package avahi-utils) when present and silently does nothing otherwise."""

    def __init__(self, port):
        self.port = port
        self.process = None

    def command(self):
        name = "TiviGrid Recorder on " + (socket.gethostname().split(".")[0] or "server")
        if sys.platform == "darwin" and shutil.which("dns-sd"):
            return ["dns-sd", "-R", name, BONJOUR_TYPE, "local", str(self.port), "v=1"]
        if shutil.which("avahi-publish"):
            return ["avahi-publish", "-s", name, BONJOUR_TYPE, str(self.port), "v=1"]
        return None

    def start(self):
        command = self.command()
        if not command:
            return False
        try:
            self.process = subprocess.Popen(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
                                            stderr=subprocess.DEVNULL)
        except OSError:
            return False
        atexit.register(self.stop)
        log(f"advertising {BONJOUR_TYPE} on port {self.port} via {command[0]}")
        return True

    def stop(self):
        if self.process and self.process.poll() is None:
            try:
                self.process.terminate()
                self.process.wait(timeout=3)
            except (OSError, subprocess.TimeoutExpired):
                pass


# ----------------------------------------------------------------------------------------------
# QR code (byte mode, error correction M, versions 1-20) for the pairing link: printed in the terminal
# and drawn by the dashboard, so the iPhone camera can open the app directly. Follows ISO/IEC 18004.

_QR_ECC_PER_BLOCK = (0, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26)
_QR_BLOCKS = (0, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16)
_QR_MASKS = (
    lambda x, y: (x + y) % 2 == 0,
    lambda x, y: y % 2 == 0,
    lambda x, y: x % 3 == 0,
    lambda x, y: (x + y) % 3 == 0,
    lambda x, y: (x // 3 + y // 2) % 2 == 0,
    lambda x, y: x * y % 2 + x * y % 3 == 0,
    lambda x, y: (x * y % 2 + x * y % 3) % 2 == 0,
    lambda x, y: ((x + y) % 2 + x * y % 3) % 2 == 0,
)


def _qr_raw_modules(version):
    """Modules available for data + error correction once the function patterns are drawn."""
    result = (16 * version + 128) * version + 64
    if version >= 2:
        n = version // 7 + 2
        result -= (25 * n - 10) * n - 55
        if version >= 7:
            result -= 36
    return result


def _gf_mul(x, y):
    z = 0
    for i in reversed(range(8)):
        z = (z << 1) ^ ((z >> 7) * 0x11D)
        z ^= ((y >> i) & 1) * x
    return z


def _rs_divisor(degree):
    result = [0] * (degree - 1) + [1]
    root = 1
    for _ in range(degree):
        for j in range(degree):
            result[j] = _gf_mul(result[j], root)
            if j + 1 < degree:
                result[j] ^= result[j + 1]
        root = _gf_mul(root, 0x02)
    return result


def _rs_remainder(data, divisor):
    result = [0] * len(divisor)
    for b in data:
        factor = b ^ result.pop(0)
        result.append(0)
        for i, coefficient in enumerate(divisor):
            result[i] ^= _gf_mul(coefficient, factor)
    return result


def _qr_codewords(data, version):
    capacity = _qr_raw_modules(version) // 8 - _QR_ECC_PER_BLOCK[version] * _QR_BLOCKS[version]
    bits = []

    def put(value, length):
        bits.extend((value >> i) & 1 for i in reversed(range(length)))

    put(0b0100, 4)  # byte mode
    put(len(data), 8 if version < 10 else 16)
    for b in data:
        put(b, 8)
    put(0, min(4, capacity * 8 - len(bits)))
    put(0, -len(bits) % 8)
    words = [int("".join(map(str, bits[i:i + 8])), 2) for i in range(0, len(bits), 8)]
    pad = 0xEC
    while len(words) < capacity:
        words.append(pad)
        pad ^= 0xEC ^ 0x11
    # Split into blocks, add Reed-Solomon error correction to each, then interleave.
    blocks_count, ecc_len = _QR_BLOCKS[version], _QR_ECC_PER_BLOCK[version]
    raw = _qr_raw_modules(version) // 8
    short_blocks, short_len = blocks_count - raw % blocks_count, raw // blocks_count
    divisor = _rs_divisor(ecc_len)
    blocks, k = [], 0
    for i in range(blocks_count):
        chunk = words[k:k + short_len - ecc_len + (0 if i < short_blocks else 1)]
        k += len(chunk)
        ecc = _rs_remainder(chunk, divisor)
        if i < short_blocks:
            chunk.append(0)  # placeholder, skipped when interleaving
        blocks.append(chunk + ecc)
    out = []
    for i in range(len(blocks[0])):
        for j, block in enumerate(blocks):
            if i != short_len - ecc_len or j >= short_blocks:
                out.append(block[i])
    return out


def _qr_penalty(grid):
    size = len(grid)
    score = 0
    lines = ["".join("1" if v else "0" for v in row) for row in grid]
    lines += ["".join("1" if grid[y][x] else "0" for y in range(size)) for x in range(size)]
    for line in lines:
        for run in re.finditer(r"0{5,}|1{5,}", line):
            score += 3 + len(run.group()) - 5
        padded = "0000" + line + "0000"
        score += 40 * (len(re.findall(r"(?=10111010000)", padded)) + len(re.findall(r"(?=00001011101)", padded)))
    for y in range(size - 1):
        for x in range(size - 1):
            if grid[y][x] == grid[y][x + 1] == grid[y + 1][x] == grid[y + 1][x + 1]:
                score += 3
    dark = sum(map(sum, grid))
    total = size * size
    score += 10 * max(0, (abs(dark * 20 - total * 10) + total - 1) // total - 1)  # dark/light balance
    return score


def qr_matrix(text):
    """QR code for `text` as rows of booleans (True = dark), without the quiet zone."""
    data = text.encode("utf-8")
    for version in range(1, 21):
        capacity = _qr_raw_modules(version) // 8 - _QR_ECC_PER_BLOCK[version] * _QR_BLOCKS[version]
        if 4 + (8 if version < 10 else 16) + 8 * len(data) <= capacity * 8:
            break
    else:
        raise ValueError("text too long for a QR code")
    size = version * 4 + 17
    grid = [[False] * size for _ in range(size)]
    reserved = [[False] * size for _ in range(size)]

    def fn(x, y, dark):
        grid[y][x] = dark
        reserved[y][x] = True

    for i in range(size):
        fn(6, i, i % 2 == 0)
        fn(i, 6, i % 2 == 0)
    for cx, cy in ((3, 3), (size - 4, 3), (3, size - 4)):
        for dy in range(-4, 5):
            for dx in range(-4, 5):
                if 0 <= cx + dx < size and 0 <= cy + dy < size:
                    fn(cx + dx, cy + dy, max(abs(dx), abs(dy)) not in (2, 4))
    if version > 1:
        count = version // 7 + 2
        step = (version * 8 + count * 3 + 5) // (count * 4 - 4) * 2
        positions = [6] + sorted(size - 7 - i * step for i in range(count - 1))
        last = len(positions) - 1
        for i, ax in enumerate(positions):
            for j, ay in enumerate(positions):
                if (i, j) in ((0, 0), (0, last), (last, 0)):
                    continue
                for dy in range(-2, 3):
                    for dx in range(-2, 3):
                        fn(ax + dx, ay + dy, max(abs(dx), abs(dy)) != 1)

    def draw_format(mask):
        value = mask  # error correction level M has format bits 00
        rem = value
        for _ in range(10):
            rem = (rem << 1) ^ ((rem >> 9) * 0x537)
        bits = ((value << 10) | rem) ^ 0x5412
        bit = [(bits >> i) & 1 == 1 for i in range(15)]
        for i in range(6):
            fn(8, i, bit[i])
        fn(8, 7, bit[6])
        fn(8, 8, bit[7])
        fn(7, 8, bit[8])
        for i in range(9, 15):
            fn(14 - i, 8, bit[i])
        for i in range(8):
            fn(size - 1 - i, 8, bit[i])
        for i in range(8, 15):
            fn(8, size - 15 + i, bit[i])
        fn(8, size - 8, True)

    draw_format(0)  # reserve the area; redrawn with the chosen mask
    if version >= 7:
        rem = version
        for _ in range(12):
            rem = (rem << 1) ^ ((rem >> 11) * 0x1F25)
        bits = (version << 12) | rem
        for i in range(18):
            a, b = size - 11 + i % 3, i // 3
            fn(a, b, (bits >> i) & 1 == 1)
            fn(b, a, (bits >> i) & 1 == 1)

    codewords = _qr_codewords(data, version)
    i = 0
    right = size - 1
    while right >= 1:
        if right == 6:
            right = 5
        for vertical in range(size):
            for j in range(2):
                x = right - j
                upward = ((right + 1) & 2) == 0
                y = size - 1 - vertical if upward else vertical
                if not reserved[y][x] and i < len(codewords) * 8:
                    grid[y][x] = (codewords[i >> 3] >> (7 - (i & 7))) & 1 == 1
                    i += 1
        right -= 2

    def masked(mask):
        rule = _QR_MASKS[mask]
        for y in range(size):
            for x in range(size):
                if not reserved[y][x] and rule(x, y):
                    grid[y][x] = not grid[y][x]

    best, best_score = 0, None
    for mask in range(8):
        masked(mask)
        draw_format(mask)
        score = _qr_penalty(grid)
        if best_score is None or score < best_score:
            best, best_score = mask, score
        masked(mask)  # XOR again to undo
    masked(best)
    draw_format(best)
    return grid


def qr_terminal(grid, border=4):
    """The QR code drawn with half-block characters, black on white whatever the terminal theme."""
    size = len(grid)
    dark = lambda x, y: 0 <= x < size and 0 <= y < size and grid[y][x]  # noqa: E731
    lines = []
    for y in range(-border, size + border, 2):
        row = ""
        for x in range(-border, size + border):
            top, bottom = dark(x, y), dark(x, y + 1)
            row += "█" if top and bottom else "▀" if top else "▄" if bottom else " "
        lines.append("\x1b[30;47m" + row + "\x1b[0m")
    return "\n".join(lines)


def print_pairing(port, token, public_url=None, qr=False):
    address = server_address(port, public_url)
    info = pairing_info(address, token)
    print(f"TiviGrid Recorder {VERSION}")
    print(f"  Server address: {address}")
    if not public_url:
        for other in local_addresses():
            if f"http://{other}:{port}" != address:
                print(f"  Also reachable: http://{other}:{port}")
    print(f"  Access token:   {token}")
    print(f"  Dashboard:      {address}/?token={urllib.parse.quote(token, safe='')}")
    print(f"  Pairing link:   {info['link']}")
    if qr:
        print("\nScan with the iPhone camera to pair TiviGrid:\n")
        print(qr_terminal(qr_matrix(info["link"])))
    sys.stdout.flush()


# ----------------------------------------------------------------------------------------------
# Web dashboard served at / and /dashboard. Kept inline so the recorder stays a single file. It holds
# no data: it asks for the token, then uses the same API as the app (provider credentials are never
# returned by the API). hls.js is loaded from a CDN only for browsers without native HLS (not Safari).

DASHBOARD_HTML = r"""<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
<meta name="color-scheme" content="dark">
<meta name="theme-color" content="#07060f">
<meta name="referrer" content="no-referrer">
<title>TiviGrid Recorder</title>
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='8' fill='%2307060f'/%3E%3Ccircle cx='16' cy='16' r='9' fill='none' stroke='%23ff4d6e' stroke-width='3'/%3E%3Ccircle cx='16' cy='16' r='4' fill='%23ff4d6e'/%3E%3C/svg%3E">
<style>
:root {
  --bg: #07060f; --ink: #f5f2ff; --ink2: #b8ade0; --pink: #ff4d6e; --lime: #b8ff3d; --cyan: #2ee3e6;
  --gold: #ffb03b; --violet: #8c5cff; --panel: rgba(140, 92, 255, .055); --panel2: rgba(245, 242, 255, .04);
  --line: rgba(184, 173, 224, .16); --radius: 18px;
  --font: ui-rounded, "SF Pro Rounded", system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
  --mono: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
}
* { box-sizing: border-box; }
html { background: var(--bg); }
body {
  margin: 0; min-height: 100vh; color: var(--ink); font: 15px/1.45 var(--font); -webkit-font-smoothing: antialiased;
  background: radial-gradient(900px 520px at 8% -10%, rgba(140, 92, 255, .22), transparent 60%),
              radial-gradient(700px 480px at 105% 110%, rgba(255, 77, 110, .14), transparent 60%), var(--bg);
  background-attachment: fixed;
  padding: max(16px, env(safe-area-inset-top)) max(16px, env(safe-area-inset-right)) 40px max(16px, env(safe-area-inset-left));
}
button, input { font: inherit; color: inherit; }
a { color: var(--cyan); }
.wrap { max-width: 1120px; margin: 0 auto; }
.hidden { display: none !important; }

/* header */
header { display: flex; align-items: center; gap: 14px; flex-wrap: wrap; padding: 6px 0 22px; }
.brand { display: flex; align-items: center; gap: 12px; margin-right: auto; }
.mark { width: 38px; height: 38px; border-radius: 12px; display: grid; place-items: center; background: #0f0c1f;
  box-shadow: 0 0 0 1px var(--line), 0 0 24px rgba(255, 77, 110, .35); }
.mark i { width: 18px; height: 18px; border-radius: 50%; border: 3px solid var(--pink); display: grid; place-items: center; }
.mark i::after { content: ""; width: 6px; height: 6px; border-radius: 50%; background: var(--pink); }
.brand h1 { margin: 0; font-size: 19px; letter-spacing: .2px; font-weight: 700; }
.brand h1 span { color: var(--pink); text-shadow: 0 0 18px rgba(255, 77, 110, .6); }
.chip { display: inline-flex; align-items: center; gap: 8px; padding: 7px 12px; border-radius: 999px; background: var(--panel2);
  border: 1px solid var(--line); color: var(--ink2); font-size: 13px; white-space: nowrap; }
.dot { width: 8px; height: 8px; border-radius: 50%; background: var(--lime); box-shadow: 0 0 10px var(--lime); }
.dot.off { background: var(--gold); box-shadow: 0 0 10px var(--gold); }
.storage { min-width: 220px; }
.meter { height: 6px; border-radius: 99px; background: rgba(245, 242, 255, .08); overflow: hidden; margin-top: 6px; }
.meter b { display: block; height: 100%; border-radius: 99px; background: linear-gradient(90deg, var(--lime), var(--cyan)); }
.storage small { color: var(--ink2); font-size: 12px; }
.ghost { background: none; border: 0; color: var(--ink2); cursor: pointer; font-size: 13px; padding: 6px 4px; }
.ghost:hover { color: var(--ink); }

/* layout */
.grid { display: grid; grid-template-columns: minmax(0, 1fr) 340px; gap: 22px; align-items: start; }
.pair { position: sticky; top: 16px; }
@media (max-width: 880px) { .grid { grid-template-columns: minmax(0, 1fr); } .pair { position: static; order: -1; } }
section { margin-bottom: 26px; }
h2 { font-size: 13px; text-transform: uppercase; letter-spacing: 1.6px; color: var(--ink2); margin: 0 0 12px; font-weight: 600;
  display: flex; align-items: center; gap: 10px; }
h2 .count { color: var(--ink); background: var(--panel2); border: 1px solid var(--line); border-radius: 99px; padding: 1px 9px;
  letter-spacing: 0; font-size: 12px; }
.card { background: var(--panel); border: 1px solid var(--line); border-radius: var(--radius); }
.list { display: grid; gap: 10px; }
.empty { padding: 22px; color: var(--ink2); text-align: center; border-style: dashed; background: transparent; }

/* recording rows */
.item { display: grid; grid-template-columns: 48px minmax(0, 1fr) auto; gap: 14px; align-items: center; padding: 12px 14px; }
.logo { width: 48px; height: 48px; border-radius: 12px; background: #120f24; border: 1px solid var(--line); display: grid;
  place-items: center; overflow: hidden; color: var(--violet); font-weight: 700; font-size: 15px; }
.logo img { width: 100%; height: 100%; object-fit: contain; padding: 5px; }
.title { font-weight: 650; font-size: 16px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.meta { color: var(--ink2); font-size: 13px; display: flex; flex-wrap: wrap; gap: 4px 12px; margin-top: 2px; }
.meta .size { font-variant-numeric: tabular-nums; }
.failure { color: var(--gold); font-size: 13px; margin-top: 4px; }
.actions { display: flex; gap: 8px; flex-wrap: wrap; justify-content: flex-end; }
.pill { display: inline-flex; align-items: center; gap: 6px; font-size: 11px; font-weight: 700; letter-spacing: 1px;
  text-transform: uppercase; padding: 3px 9px; border-radius: 99px; border: 1px solid currentColor; }
.pill.recording { color: var(--pink); } .pill.scheduled { color: var(--cyan); }
.pill.completed { color: var(--lime); } .pill.failed { color: var(--gold); }
.pill.recording::before { content: ""; width: 7px; height: 7px; border-radius: 50%; background: var(--pink);
  box-shadow: 0 0 10px var(--pink); animation: pulse 1.4s ease-in-out infinite; }
@keyframes pulse { 50% { opacity: .25; } }
.item.live { border-color: rgba(255, 77, 110, .45); box-shadow: 0 0 0 1px rgba(255, 77, 110, .15), 0 10px 40px -18px rgba(255, 77, 110, .55); }
.progress { grid-column: 1 / -1; height: 4px; border-radius: 99px; background: rgba(245, 242, 255, .07); overflow: hidden; }
.progress b { display: block; height: 100%; background: linear-gradient(90deg, var(--violet), var(--pink)); box-shadow: 0 0 12px var(--pink); }
@media (max-width: 560px) {
  .item { grid-template-columns: 44px minmax(0, 1fr); }
  .logo { width: 44px; height: 44px; }
  .actions { grid-column: 1 / -1; justify-content: flex-start; }
  .title { white-space: normal; }
}

/* buttons */
.btn { display: inline-flex; align-items: center; justify-content: center; gap: 7px; min-height: 36px; padding: 0 14px;
  border-radius: 11px; border: 1px solid var(--line); background: var(--panel2); cursor: pointer; font-size: 14px;
  font-weight: 600; text-decoration: none; color: var(--ink); transition: border-color .15s, background .15s, transform .1s; }
.btn:hover { border-color: rgba(184, 173, 224, .4); background: rgba(245, 242, 255, .08); }
.btn:active { transform: scale(.97); }
.btn:focus-visible, input:focus-visible { outline: 2px solid var(--cyan); outline-offset: 2px; }
.btn.watch { color: #07060f; background: var(--lime); border-color: var(--lime); }
.btn.watch:hover { background: #ccff70; }
.btn.stop { color: var(--pink); border-color: rgba(255, 77, 110, .5); }
.btn.danger:hover { color: var(--pink); border-color: rgba(255, 77, 110, .5); }
.btn.primary { color: #fff; border: 0; background: linear-gradient(135deg, var(--pink), var(--violet));
  box-shadow: 0 10px 30px -10px rgba(255, 77, 110, .7); }
.btn.big { width: 100%; min-height: 52px; font-size: 16px; border-radius: 14px; }
.btn[disabled] { opacity: .45; pointer-events: none; }

/* pairing panel */
.pair { padding: 18px; }
.pair h3 { margin: 0 0 4px; font-size: 17px; }
.pair p { margin: 0 0 14px; color: var(--ink2); font-size: 13px; }
.qr { background: #fff; border-radius: 14px; padding: 10px; margin: 0 auto 14px; width: 100%; max-width: 236px;
  box-shadow: 0 0 0 1px var(--line), 0 0 40px -6px rgba(46, 227, 230, .45); }
.qr svg { display: block; width: 100%; height: auto; }
.field { margin-top: 12px; }
.field label { display: block; font-size: 11px; color: var(--ink2); text-transform: uppercase; letter-spacing: 1.3px; margin-bottom: 5px; }
.copy { display: flex; gap: 8px; }
.copy code { flex: 1; min-width: 0; font: 13px/1.2 var(--mono); padding: 10px 11px; border-radius: 10px; background: #0d0a1c;
  border: 1px solid var(--line); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--cyan); }
.copy .btn { min-height: 0; padding: 0 12px; font-size: 13px; }
.pair details summary { cursor: pointer; color: var(--ink2); font-size: 13px; margin-top: 14px; list-style: none; }
.pair details summary::-webkit-details-marker { display: none; }
.pair details summary::before { content: "+ "; color: var(--cyan); }
.pair details[open] summary::before { content: "– "; }
@media (max-width: 880px) { .qr-wrap { display: none; } }
@media (min-width: 881px) { .pair details summary { display: none; } }

/* login */
.login { max-width: 420px; margin: 9vh auto 0; padding: 26px; }
.login h2 { text-transform: none; letter-spacing: 0; color: var(--ink); font-size: 22px; margin-bottom: 6px; }
.login p { color: var(--ink2); margin: 0 0 18px; font-size: 14px; }
.login input { width: 100%; padding: 13px 14px; border-radius: 12px; border: 1px solid var(--line); background: #0d0a1c;
  font-family: var(--mono); font-size: 15px; margin-bottom: 12px; }
.login .err { color: var(--pink); font-size: 13px; min-height: 20px; margin: -4px 0 8px; }
.login code { font-family: var(--mono); color: var(--cyan); font-size: 12px; }

/* player */
dialog { border: 0; padding: 0; background: transparent; max-width: min(1100px, 100vw); width: 100%; color: var(--ink); }
dialog::backdrop { background: rgba(4, 3, 10, .86); backdrop-filter: blur(6px); -webkit-backdrop-filter: blur(6px); }
.player { padding: 12px; }
.player .bar { display: flex; align-items: center; gap: 10px; padding: 2px 4px 10px; }
.player .bar strong { margin-right: auto; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
video { display: block; width: 100%; max-height: 78vh; border-radius: 12px; background: #000; }

.toast { position: fixed; left: 50%; bottom: max(20px, env(safe-area-inset-bottom)); transform: translateX(-50%) translateY(20px);
  background: #151129; border: 1px solid var(--line); padding: 11px 16px; border-radius: 12px; opacity: 0; pointer-events: none;
  transition: opacity .2s, transform .2s; max-width: calc(100vw - 32px); font-size: 14px; z-index: 10; }
.toast.show { opacity: 1; transform: translateX(-50%); }
@media (prefers-reduced-motion: reduce) { * { animation: none !important; transition: none !important; } }
</style>
</head>
<body>
<div class="wrap">
  <header>
    <div class="brand"><div class="mark"><i></i></div><h1>TiviGrid <span>Recorder</span></h1></div>
    <div id="server" class="chip hidden"><span class="dot" id="online"></span><span id="server-name"></span></div>
    <div id="storage" class="chip storage hidden"><div style="width:100%"><span id="free"></span>
      <div class="meter"><b id="used"></b></div><small id="hours"></small></div></div>
    <button id="logout" class="ghost hidden" type="button">Sign out</button>
  </header>

  <form id="login" class="card login hidden" autocomplete="off">
    <h2>Connect to your recorder</h2>
    <p>Enter the access token. The installer printed it; you can show it again with
      <code>install.sh --status</code> or <code>xtreamtv_recorder.py --pairing</code>.</p>
    <input id="token" type="password" placeholder="Access token" aria-label="Access token" autocapitalize="off" spellcheck="false" required>
    <div class="err" id="login-error" role="alert"></div>
    <button class="btn primary big" type="submit">Connect</button>
  </form>

  <main id="app" class="grid hidden">
    <div>
      <section><h2>Recording now <span class="count" id="n-live">0</span></h2><div class="list" id="live"></div></section>
      <section><h2>Upcoming <span class="count" id="n-next">0</span></h2><div class="list" id="next"></div></section>
      <section><h2>Recordings <span class="count" id="n-done">0</span></h2><div class="list" id="done"></div></section>
    </div>
    <aside class="card pair">
      <h3>Pair your iPhone</h3>
      <p>On the iPhone, tap the button. On a computer, scan the code with the iPhone camera.</p>
      <a id="pair-link" class="btn primary big" href="#">Open in TiviGrid</a>
      <details id="pair-details">
        <summary>Address and token</summary>
        <div class="field qr-wrap"><div class="qr" id="qr" aria-label="Pairing QR code" role="img"></div></div>
        <div class="field"><label>Server address</label><div class="copy"><code id="pair-address"></code>
          <button class="btn" type="button" data-copy="pair-address">Copy</button></div></div>
        <div class="field"><label>Access token</label><div class="copy"><code id="pair-token"></code>
          <button class="btn" type="button" data-copy="pair-token">Copy</button></div></div>
      </details>
    </aside>
  </main>
</div>

<dialog id="player"><div class="card player">
  <div class="bar"><strong id="player-title"></strong><a id="player-download" class="btn" href="#">Download</a>
    <button class="btn" type="button" id="player-close">Close</button></div>
  <video id="video" controls playsinline></video>
</div></dialog>
<div class="toast" id="toast" role="status"></div>

<script>
"use strict";
const HLS_JS = "https://cdn.jsdelivr.net/npm/hls.js@1.7.3/dist/hls.min.js";
const HLS_SRI = "sha384-cciJ0zi8d1uMKC2zJd7jvPY4HQt7W4ByUI/FlMkltvBi31aW61rcpVBhpmW8/NwX";
const $ = (id) => document.getElementById(id);
let token = "";
let clockOffset = 0;   // server time - local time, seconds
let timer = null;
let hls = null;

function readToken() {
  const url = new URL(location.href);
  const fromUrl = url.searchParams.get("token");
  if (fromUrl) {
    try { localStorage.setItem("xtreamtv.token", fromUrl); } catch (e) {}
    url.searchParams.delete("token");
    history.replaceState(null, "", url.pathname + url.search + url.hash);  // keep the token out of history
    return fromUrl;
  }
  try { return localStorage.getItem("xtreamtv.token") || ""; } catch (e) { return ""; }
}

async function api(path, options = {}) {
  const response = await fetch(path, { ...options, headers: { Authorization: "Bearer " + token }, cache: "no-store" });
  if (response.status === 401) { const e = new Error("unauthorized"); e.status = 401; throw e; }
  if (!response.ok) {
    let message = "HTTP " + response.status;
    try { message = (await response.json()).error || message; } catch (e) {}
    throw new Error(message);
  }
  return response.json();
}

function el(tag, attrs, ...children) {
  const node = document.createElement(tag);
  for (const [key, value] of Object.entries(attrs || {})) {
    if (value == null || value === false) continue;
    if (key === "class") node.className = value;
    else if (key.startsWith("on")) node.addEventListener(key.slice(2), value);
    else node.setAttribute(key, value);
  }
  for (const child of children.flat()) if (child != null && child !== false) node.append(child);
  return node;
}

function toast(message) {
  const t = $("toast");
  t.textContent = message;
  t.classList.add("show");
  clearTimeout(toast.timer);
  toast.timer = setTimeout(() => t.classList.remove("show"), 3200);
}

const gb = (bytes) => bytes >= 1e9 ? (bytes / 1e9).toFixed(1) + " GB" : Math.round((bytes || 0) / 1e6) + " MB";
const now = () => Date.now() / 1000 + clockOffset;
const dayFmt = new Intl.DateTimeFormat(undefined, { weekday: "short", day: "numeric", month: "short" });
const timeFmt = new Intl.DateTimeFormat(undefined, { hour: "2-digit", minute: "2-digit" });
function span(seconds) {
  seconds = Math.max(0, Math.round(seconds));
  const h = Math.floor(seconds / 3600), m = Math.floor(seconds % 3600 / 60);
  return h ? h + " h " + (m ? m + " min" : "") : m ? m + " min" : seconds + " s";
}
function when(item) {
  const a = new Date(item.start * 1000), b = new Date(item.end * 1000);
  return dayFmt.format(a) + " · " + timeFmt.format(a) + "–" + timeFmt.format(b);
}

function logo(item) {
  const initials = (item.channel_name || item.title || "?").replace(/[^\p{L}\p{N} ]/gu, "").trim()
    .split(/\s+/).slice(0, 2).map((w) => w[0]).join("").toUpperCase() || "TV";
  const box = el("div", { class: "logo" }, initials);
  if (/^https?:\/\//i.test(item.channel_icon || "")) {
    const img = el("img", { src: item.channel_icon, alt: "", loading: "lazy", referrerpolicy: "no-referrer" });
    img.addEventListener("load", () => { box.textContent = ""; box.append(img); });
  }
  return box;
}

const LABELS = { scheduled: "Scheduled", recording: "Recording", completed: "Recorded", failed: "Failed" };

function row(item) {
  const live = item.status === "recording";
  const meta = [el("span", null, item.channel_name || "Channel " + item.channel_id), el("span", null, when(item))];
  if (item.status === "scheduled") {
    const wait = item.start - now();
    meta.push(el("span", null, wait > 0 ? "starts in " + span(wait) : "starting…"));
  } else {
    if (item.duration) meta.push(el("span", null, span(item.duration)));
    if (item.bytes) meta.push(el("span", { class: "size" }, gb(item.bytes)));
  }
  const playable = (live || item.status === "completed") && item.bytes > 0;
  const actions = el("div", { class: "actions" },
    playable && el("button", { class: "btn watch", type: "button", onclick: () => watch(item) }, "▶ Watch"),
    live && el("button", { class: "btn stop", type: "button", onclick: (e) => stop(item, e.currentTarget) }, "■ Stop"),
    el("button", { class: "btn danger", type: "button", onclick: (e) => remove(item, e.currentTarget) },
      item.status === "scheduled" ? "Cancel" : "Delete"));
  const card = el("div", { class: "card item" + (live ? " live" : "") },
    logo(item),
    el("div", null,
      el("div", { class: "title", title: item.title, dir: "auto" }, item.title),
      el("div", { class: "meta" }, el("span", { class: "pill " + item.status }, LABELS[item.status] || item.status), meta),
      item.failure && el("div", { class: "failure" }, item.failure),
      item.interrupted && item.status !== "failed" && el("div", { class: "failure" }, "Interrupted by a restart; there may be a gap.")),
    actions);
  if (live) {
    const pct = Math.min(100, Math.max(0, (now() - item.start) / (item.end - item.start) * 100));
    card.append(el("div", { class: "progress" }, el("b", { style: "width:" + pct.toFixed(1) + "%" })));
  }
  return card;
}

function fill(id, items, emptyText) {
  $("n-" + id).textContent = items.length;
  $(id).replaceChildren(...(items.length ? items.map(row) : [el("div", { class: "card empty" }, emptyText)]));
}

async function refresh() {
  try {
    const [info, items] = await Promise.all([api("/api/info"), api("/api/recordings")]);
    clockOffset = info.time - Date.now() / 1000;
    $("server-name").textContent = info.name + " · v" + info.version;
    $("online").classList.remove("off");
    $("server").classList.remove("hidden");
    $("storage").classList.remove("hidden");
    $("free").textContent = gb(info.free_bytes) + " free";
    $("used").style.width = ((1 - info.free_bytes / info.total_bytes) * 100).toFixed(1) + "%";
    $("hours").textContent = "≈ " + Math.floor(info.free_bytes / 2.75e9) + " h of full-HD recording";
    fill("live", items.filter((i) => i.status === "recording"), "Nothing is recording right now.");
    fill("next", items.filter((i) => i.status === "scheduled"),
      "No timers. Schedule recordings from the TV guide in TiviGrid.");
    fill("done", items.filter((i) => i.status === "completed" || i.status === "failed").reverse(),
      "Finished recordings appear here.");
  } catch (e) {
    if (e.status === 401) return signOut("That token was not accepted.");
    $("online").classList.add("off");
    $("server-name").textContent = "Can't reach the recorder";
  }
}

function drawQR(rows) {
  const n = rows.length, q = 4, size = n + q * 2;
  let d = "";
  rows.forEach((line, y) => { for (let x = 0; x < n; x++) if (line[x] === "1") d += "M" + (x + q) + " " + (y + q) + "h1v1h-1z"; });
  $("qr").innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ' + size + " " + size +
    '" shape-rendering="crispEdges"><path fill="#07060f" d="' + d + '"/></svg>';
}

async function loadPairing() {
  try {
    const pairing = await api("/api/pairing");
    $("pair-link").href = pairing.link;
    $("pair-address").textContent = pairing.address;
    $("pair-token").textContent = pairing.token;
    drawQR(pairing.qr);
  } catch (e) {}
}

async function copy(text, button) {
  try {
    await navigator.clipboard.writeText(text);  // needs https or localhost
  } catch (e) {
    const area = el("textarea", { readonly: "", style: "position:fixed;opacity:0" });
    area.value = text;
    document.body.append(area);
    area.select();
    document.execCommand("copy");
    area.remove();
  }
  const label = button.textContent;
  button.textContent = "Copied";
  setTimeout(() => (button.textContent = label), 1400);
}

async function stop(item, button) {
  button.disabled = true;
  try { await api("/api/recordings/" + item.id + "/stop", { method: "POST" }); toast("Stopping “" + item.title + "”"); }
  catch (e) { toast(e.message); }
  setTimeout(refresh, 800);
}

async function remove(item, button) {
  const what = item.status === "scheduled" ? "Cancel the timer for" : "Delete the recording";
  if (!confirm(what + " “" + item.title + "”?")) return;
  button.disabled = true;
  try { await api("/api/recordings/" + item.id, { method: "DELETE" }); toast("Removed “" + item.title + "”"); }
  catch (e) { toast(e.message); }
  refresh();
}

function loadHlsJs() {
  if (window.Hls) return Promise.resolve();
  return new Promise((resolve, reject) => {
    const script = el("script", { src: HLS_JS, integrity: HLS_SRI, crossorigin: "anonymous" });
    script.onload = resolve;
    script.onerror = () => reject(new Error("Couldn't load the player (no internet?). Use Download instead."));
    document.head.append(script);
  });
}

async function watch(item) {
  const base = "/api/recordings/" + item.id;
  const q = "?token=" + encodeURIComponent(token);
  const src = base + "/index.m3u8" + q;
  $("player-title").textContent = item.title;
  $("player-download").href = base + "/media.ts" + q;
  // A just-finished recording may still be indexed (503): wait for it briefly.
  for (let attempt = 0; ; attempt++) {
    const response = await fetch(src, { method: "HEAD", cache: "no-store" });
    if (response.ok) break;
    if (response.status !== 503 || attempt >= 10) return toast("This recording can't be played yet.");
    if (attempt === 0) toast("Preparing the recording…");
    await new Promise((r) => setTimeout(r, 2500));
  }
  const video = $("video");
  $("player").showModal();
  if (video.canPlayType("application/vnd.apple.mpegurl")) {
    video.src = src;  // Safari and iOS play HLS natively
  } else {
    try { await loadHlsJs(); } catch (e) { return toast(e.message); }
    if (!window.Hls.isSupported()) return toast("This browser can't play HLS. Use Download instead.");
    hls = new window.Hls();
    hls.loadSource(src);
    hls.attachMedia(video);
  }
  video.play().catch(() => {});
}

function closePlayer() {
  const video = $("video");
  video.pause();
  if (hls) { hls.destroy(); hls = null; }
  video.removeAttribute("src");
  video.load();
  if ($("player").open) $("player").close();
}

function signOut(message) {
  token = "";
  try { localStorage.removeItem("xtreamtv.token"); } catch (e) {}
  clearInterval(timer);
  $("app").classList.add("hidden");
  ["server", "storage", "logout"].forEach((id) => $(id).classList.add("hidden"));
  $("login").classList.remove("hidden");
  $("login-error").textContent = message || "";
  $("token").focus();
}

async function signIn(candidate) {
  token = candidate;
  try {
    await api("/api/info");
  } catch (e) {
    if (e.status === 401) return signOut("That token was not accepted.");
    $("login").classList.remove("hidden");
    $("login-error").textContent = "Can't reach the recorder.";
    return;
  }
  try { localStorage.setItem("xtreamtv.token", token); } catch (e) {}
  $("login").classList.add("hidden");
  $("app").classList.remove("hidden");
  $("logout").classList.remove("hidden");
  refresh();
  loadPairing();
  clearInterval(timer);
  timer = setInterval(() => { if (document.visibilityState === "visible") refresh(); }, 5000);
}

$("login").addEventListener("submit", (e) => { e.preventDefault(); signIn($("token").value.trim()); });
$("logout").addEventListener("click", () => signOut());
$("player-close").addEventListener("click", closePlayer);
$("player").addEventListener("close", closePlayer);
document.addEventListener("visibilitychange", () => { if (document.visibilityState === "visible" && token) refresh(); });
document.querySelectorAll("[data-copy]").forEach((b) =>
  b.addEventListener("click", () => copy($(b.dataset.copy).textContent, b)));
if (matchMedia("(min-width: 881px)").matches) $("pair-details").open = true;

const saved = readToken();
if (saved) signIn(saved); else signOut();
</script>
</body>
</html>
"""


def main():
    parser = argparse.ArgumentParser(description="TiviGrid Recorder")
    parser.add_argument("--data", default=os.environ.get("RECORDER_DATA", "./recorder-data"),
                        help="folder for recordings and settings")
    parser.add_argument("--host", default=os.environ.get("RECORDER_HOST", "0.0.0.0"))
    parser.add_argument("--port", type=int, default=int(os.environ.get("RECORDER_PORT", "8765")))
    parser.add_argument("--token", default=os.environ.get("RECORDER_TOKEN"),
                        help="access token (default: generated once and saved)")
    parser.add_argument("--public-url", default=os.environ.get("RECORDER_PUBLIC_URL"),
                        help="address the phone should use, e.g. http://192.168.1.20:8765 (Docker, Tailscale)")
    parser.add_argument("--no-mdns", action="store_true", default=bool(os.environ.get("RECORDER_NO_MDNS")),
                        help="don't advertise the recorder on the local network (Bonjour)")
    parser.add_argument("--pairing", action="store_true",
                        help="print the address, token and pairing link (and a QR code in a terminal), then exit")
    parser.add_argument("--qr", action="store_true", help="with --pairing: print the QR code even when not in a terminal")
    args = parser.parse_args()

    root = os.path.abspath(args.data)
    os.makedirs(root, exist_ok=True)
    token = load_token(root, args.token)
    if args.pairing:
        print_pairing(args.port, token, args.public_url, qr=args.qr or sys.stdout.isatty())
        return
    store = Store(root)
    scheduler = Scheduler(store)
    scheduler.start()
    server = RecorderHTTPServer((args.host, args.port), make_handler(store, scheduler, token, args.public_url))
    server.daemon_threads = True
    port = server.server_address[1]
    # systemd and launchd stop services with SIGTERM: exit cleanly so the Bonjour helper is stopped too.
    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
    if not args.no_mdns:
        Bonjour(port).start()
    address = server_address(port, args.public_url)
    log(f"TiviGrid Recorder {VERSION} — data in {root}")
    log(f"Server address: {address}")
    log(f"Access token:   {token}")
    log(f"Dashboard:      {address}/")
    log(f"Pairing link:   {pairing_link(address, token)}")
    print(f"READY {port}", flush=True)
    try:
        server.serve_forever()
    except (KeyboardInterrupt, SystemExit):
        log("stopping")


if __name__ == "__main__":
    main()