#!/usr/bin/env python3
"""Webcam-Relay: holt den MJPEG-Stream der Kamera einmal ab und stellt ihn
per HTTP für beliebig viele Zuschauer bereit (hinter Zoraxy / Reverse Proxy).

Endpunkte:
  /                      Übersicht aller Kameras (Web-Frontend, frontend.html)
  /<name>/               Webseite mit Livebild einer Kamera
  /status.json           Status aller Kameras (vom Frontend abgefragt)
  /<name>/stream.mjpg    Livestream (multipart/x-mixed-replace)
  /<name>/snapshot.jpg   aktuelles Einzelbild
  POST /<name>/timelapse Timelapse einer Kamera steuern, Body: {"enabled": true, "interval": 300}
  POST /<name>/setup     ruft die in SETUP_<name> hinterlegte Kamera-URL auf
  /<name>/timelapse.json          Liste der Timelapse-Bilder je Tag
  /<name>/timelapse/<tag>/<datei> einzelnes Timelapse-Bild
  /stream.mjpg           Alias für die erste Kamera (Abwärtskompatibilität)
  /health                Status aller Kameras

Konfiguration über die Datei .env (neben relay.py) oder Umgebungsvariablen:
  CAMERA_<name>=<url>     eine Zeile pro Kamera, z.B. CAMERA_cam1=http://...
  SETUP_<name>=<url>      optional: Konfigurations-URL der Kamera (Button "Setup" im Frontend),
                          z.B. http://IP/control?var=framesize&val=11
  TIMELAPSE_INTERVAL=<sek>  Standard-Intervall der Timelapse (default 300); ein/aus und Intervall
                            stellt man pro Kamera im Frontend ein
  TIMELAPSE_DIR=<pfad>      Zielordner (default: timelapse neben relay.py)
  TIMELAPSE_KEEP_DAYS=<n>   Tage aufbewahren (0 = unbegrenzt, default)
  PORT        (default 8000)
  AUTH_USER / AUTH_PASS   optional: Basic-Auth (nur sinnvoll mit HTTPS in Zoraxy)
"""
import base64
import hmac
import json
import os
import re
import shutil
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

import requests



def load_env(path):
    """Liest KEY=VALUE-Zeilen aus .env; echte Umgebungsvariablen haben Vorrang."""
    try:
        with open(path, encoding="utf-8") as f:
            for line in f:
                line = line.strip()
                if line and not line.startswith("#") and "=" in line:
                    k, v = line.split("=", 1)
                    os.environ.setdefault(k.strip(), v.strip().strip("\"'"))
    except FileNotFoundError:
        pass


load_env(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env"))
CAMERAS = {k[7:].lower(): v for k, v in os.environ.items() if k.startswith("CAMERA_") and v}
if not CAMERAS:
    raise SystemExit("Keine Kameras konfiguriert: CAMERA_<name>=<url> in .env eintragen")
SETUPS = {k[6:].lower(): v for k, v in os.environ.items()
          if k.startswith("SETUP_") and v and k[6:].lower() in CAMERAS}
PORT = int(os.environ.get("PORT", "8000"))
AUTH_USER = os.environ.get("AUTH_USER", "")
AUTH_PASS = os.environ.get("AUTH_PASS", "")
BOUNDARY = "frame"
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
TL_INTERVAL = int(os.environ.get("TIMELAPSE_INTERVAL", "300"))
TL_DIR = os.path.abspath(os.environ.get("TIMELAPSE_DIR") or os.path.join(BASE_DIR, "timelapse"))
TL_KEEP_DAYS = int(os.environ.get("TIMELAPSE_KEEP_DAYS", "0"))
DAY_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
FILE_RE = re.compile(r"^\d{6}\.jpg$")

FRONTEND = os.path.join(os.path.dirname(os.path.abspath(__file__)), "frontend.html")


def page(root, current):
    """Frontend ausliefern; Links sind relativ, damit es auch unter einem Proxy-Prefix läuft."""
    with open(FRONTEND, encoding="utf-8") as f:
        html = f.read()
    return (html.replace("__ROOT__", json.dumps(root))
                .replace("__CURRENT__", json.dumps(current))).encode()


class Hub:
    """Hält das neueste Frame; Zuschauer warten auf das jeweils nächste."""

    def __init__(self):
        self.cond = threading.Condition()
        self.frame = None
        self.seq = 0
        self.last = 0.0

    def publish(self, jpg):
        with self.cond:
            self.frame, self.seq, self.last = jpg, self.seq + 1, time.time()
            self.cond.notify_all()

    def wait(self, seq, timeout=10):
        with self.cond:
            self.cond.wait_for(lambda: self.seq != seq, timeout)
            return self.frame, self.seq


hubs = {name: Hub() for name in CAMERAS}


def is_online(hub):
    return bool(hub.last) and time.time() - hub.last < 10


def pull_camera(name, url, hub):
    """Liest die Kamera dauerhaft; baut die Verbindung bei Fehlern neu auf."""
    while True:
        try:
            with requests.get(url, stream=True, timeout=10) as r:
                r.raise_for_status()
                buf = b""
                for chunk in r.iter_content(chunk_size=8192):
                    buf += chunk
                    while True:
                        s = buf.find(b"\xff\xd8")
                        if s < 0:
                            buf = b""
                            break
                        e = buf.find(b"\xff\xd9", s + 2)
                        if e < 0:
                            buf = buf[s:]
                            break
                        hub.publish(buf[s:e + 2])
                        buf = buf[e + 2:]
        except requests.RequestException as ex:
            print(f"{name}: Kamera nicht erreichbar: {ex} - neuer Versuch in 3s", flush=True)
        time.sleep(3)


TL_STATE_FILE = os.path.join(TL_DIR, "state.json")
TL_INTERVALS = (10, 30, 60, 300, 900, 1800, 3600)
tl_lock = threading.Lock()


def load_tl_state():
    try:
        with open(TL_STATE_FILE, encoding="utf-8") as f:
            saved = json.load(f)
    except (OSError, ValueError):
        saved = {}
    return {n: {"enabled": bool(saved.get(n, {}).get("enabled")),
                "interval": int(saved.get(n, {}).get("interval", TL_INTERVAL))} for n in CAMERAS}


tl_state = load_tl_state()


def save_tl_state():
    try:
        os.makedirs(TL_DIR, exist_ok=True)
        with open(TL_STATE_FILE + ".tmp", "w", encoding="utf-8") as f:
            json.dump(tl_state, f)
        os.replace(TL_STATE_FILE + ".tmp", TL_STATE_FILE)
    except OSError as ex:
        print(f"Timelapse-Zustand nicht gespeichert: {ex}", flush=True)


def timelapse(name, hub):
    """Speichert, solange für die Kamera aktiviert, im Intervall das aktuelle Bild
    nach TL_DIR/<name>/<tag>/<HHMMSS>.jpg."""
    last_seq, last_t = 0, 0.0
    while True:
        time.sleep(1)
        st = tl_state[name]
        if not st["enabled"] or time.time() - last_t < st["interval"]:
            continue
        frame, seq = hub.frame, hub.seq
        if frame is None or seq == last_seq or not is_online(hub):
            continue
        last_seq, last_t = seq, time.time()
        now = time.localtime()
        folder = os.path.join(TL_DIR, name, time.strftime("%Y-%m-%d", now))
        try:
            os.makedirs(folder, exist_ok=True)
            tmp = os.path.join(folder, ".tmp")
            with open(tmp, "wb") as f:
                f.write(frame)
            os.replace(tmp, os.path.join(folder, time.strftime("%H%M%S", now) + ".jpg"))
            if TL_KEEP_DAYS:
                prune(os.path.join(TL_DIR, name))
        except OSError as ex:
            print(f"{name}: Timelapse-Bild nicht gespeichert: {ex}", flush=True)


def prune(cam_dir):
    """Löscht Tagesordner, die älter als TL_KEEP_DAYS sind."""
    limit = time.strftime("%Y-%m-%d", time.localtime(time.time() - TL_KEEP_DAYS * 86400))
    for day in os.listdir(cam_dir):
        if DAY_RE.match(day) and day < limit:
            shutil.rmtree(os.path.join(cam_dir, day), ignore_errors=True)


def timelapse_index(name):
    """{"interval": sek, "days": {tag: [dateien]}} aus dem Dateisystem."""
    days = {}
    cam_dir = os.path.join(TL_DIR, name)
    try:
        for day in sorted(os.listdir(cam_dir), reverse=True):
            if DAY_RE.match(day):
                days[day] = sorted(f for f in os.listdir(os.path.join(cam_dir, day)) if FILE_RE.match(f))
    except FileNotFoundError:
        pass
    return {**tl_state[name], "days": days}


class Handler(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, fmt, *args):
        pass

    def authorized(self):
        if not AUTH_USER:
            return True
        h = self.headers.get("Authorization", "")
        want = "Basic " + base64.b64encode(f"{AUTH_USER}:{AUTH_PASS}".encode()).decode()
        return hmac.compare_digest(h, want)

    def send_bytes(self, code, ctype, body, extra=None):
        self.send_response(code)
        self.send_header("Content-Type", ctype)
        self.send_header("Content-Length", str(len(body)))
        extra = extra or {}
        if "Cache-Control" not in extra:
            self.send_header("Cache-Control", "no-store")
        for k, v in extra.items():
            self.send_header(k, v)
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        parts = [p for p in self.path.split("?")[0].split("/") if p]
        if parts == ["health"]:
            lines = [f"{n}: {'ok' if is_online(h) else 'keine Frames'}" for n, h in hubs.items()]
            ok = all(l.endswith(": ok") for l in lines)
            return self.send_bytes(200 if ok else 503, "text/plain", ("\n".join(lines) + "\n").encode())
        if not self.authorized():
            return self.send_bytes(401, "text/plain", b"Login erforderlich",
                                   {"WWW-Authenticate": 'Basic realm="Webcam"'})
        if not parts:
            return self.send_bytes(200, "text/html; charset=utf-8", page("", ""))
        if parts == ["status.json"]:
            body = json.dumps({"cameras": [{"name": n, "online": is_online(h), "setup": n in SETUPS,
                                            "timelapse": tl_state[n]}
                                           for n, h in hubs.items()]}).encode()
            return self.send_bytes(200, "application/json", body)
        if parts == ["stream.mjpg"] or parts == ["snapshot.jpg"]:
            parts = [next(iter(CAMERAS))] + parts  # Alias: erste Kamera
        name = parts[0]
        if name in hubs and len(parts) == 2 and parts[1] == "timelapse.json":
            return self.send_bytes(200, "application/json", json.dumps(timelapse_index(name)).encode())
        if name in hubs and len(parts) == 4 and parts[1] == "timelapse":
            if not (DAY_RE.match(parts[2]) and FILE_RE.match(parts[3])):
                return self.send_bytes(404, "text/plain", b"Nicht gefunden")
            try:
                with open(os.path.join(TL_DIR, name, parts[2], parts[3]), "rb") as f:
                    body = f.read()
            except FileNotFoundError:
                return self.send_bytes(404, "text/plain", b"Nicht gefunden")
            return self.send_bytes(200, "image/jpeg", body, {"Cache-Control": "max-age=86400"})
        if name not in hubs or len(parts) > 2:
            return self.send_bytes(404, "text/plain", b"Nicht gefunden")
        hub = hubs[name]
        what = parts[1] if len(parts) == 2 else ""
        if what == "":
            if not self.path.split("?")[0].endswith("/"):
                return self.send_bytes(301, "text/plain", b"", {"Location": f"{name}/"})  # relativ: Proxy-Prefix bleibt erhalten
            return self.send_bytes(200, "text/html; charset=utf-8", page("../", name))
        if what == "snapshot.jpg":
            if hub.frame is None:
                return self.send_bytes(503, "text/plain", b"Noch kein Bild")
            return self.send_bytes(200, "image/jpeg", hub.frame)
        if what == "stream.mjpg":
            return self.stream(hub)
        self.send_bytes(404, "text/plain", b"Nicht gefunden")

    def do_POST(self):
        if not self.authorized():
            return self.send_bytes(401, "text/plain", b"Login erforderlich",
                                   {"WWW-Authenticate": 'Basic realm="Webcam"'})
        parts = [p for p in self.path.split("?")[0].split("/") if p]
        if len(parts) == 2 and parts[1] == "timelapse" and parts[0] in hubs:
            try:
                n = int(self.headers.get("Content-Length", 0))
                req = json.loads(self.rfile.read(n) or b"{}")
                with tl_lock:
                    st = tl_state[parts[0]]
                    if "enabled" in req:
                        st["enabled"] = bool(req["enabled"])
                    if int(req.get("interval", st["interval"])) in TL_INTERVALS:
                        st["interval"] = int(req.get("interval", st["interval"]))
                    save_tl_state()
            except (ValueError, TypeError):
                return self.send_bytes(400, "text/plain", b"Ungueltige Anfrage")
            return self.send_bytes(200, "application/json", json.dumps(tl_state[parts[0]]).encode())
        if len(parts) != 2 or parts[1] != "setup" or parts[0] not in SETUPS:
            return self.send_bytes(404, "text/plain", b"Nicht gefunden")
        try:
            r = requests.get(SETUPS[parts[0]], timeout=5)
            r.raise_for_status()
        except requests.RequestException as ex:
            print(f"{parts[0]}: Setup fehlgeschlagen: {ex}", flush=True)
            return self.send_bytes(502, "text/plain", b"Kamera nicht erreichbar")
        self.send_bytes(200, "text/plain", b"ok")

    def stream(self, hub):
        self.send_response(200)
        self.send_header("Content-Type", f"multipart/x-mixed-replace; boundary={BOUNDARY}")
        self.send_header("Cache-Control", "no-store")
        self.send_header("X-Accel-Buffering", "no")  # Proxy soll nicht puffern
        self.send_header("Connection", "close")
        self.end_headers()
        self.close_connection = True
        seq = 0
        try:
            while True:
                frame, seq_new = hub.wait(seq)
                if frame is None or seq_new == seq:
                    continue
                seq = seq_new
                self.wfile.write(
                    f"--{BOUNDARY}\r\nContent-Type: image/jpeg\r\n"
                    f"Content-Length: {len(frame)}\r\n\r\n".encode() + frame + b"\r\n")
                self.wfile.flush()
        except (BrokenPipeError, ConnectionResetError, TimeoutError):
            pass


class Server(ThreadingHTTPServer):
    daemon_threads = True
    allow_reuse_address = True


if __name__ == "__main__":
    for n, u in CAMERAS.items():
        threading.Thread(target=pull_camera, args=(n, u, hubs[n]), daemon=True).start()
        threading.Thread(target=timelapse, args=(n, hubs[n]), daemon=True).start()
    print(f"Relay läuft auf Port {PORT}, Kameras: {', '.join(CAMERAS)}", flush=True)
    print(f"Timelapse-Ordner: {TL_DIR}", flush=True)
    Server(("0.0.0.0", PORT), Handler).serve_forever()