"""Ein Kameraproduzent für mehrere Livebild-Betrachter."""

from collections import deque
from io import BytesIO
import threading
import time
from datetime import datetime

from PIL import Image, ImageDraw


class CameraStream:
    TARGET_FPS = 15
    def __init__(self, demo: bool = False):
        self.demo = demo
        self._condition = threading.Condition()
        self._thread = None
        self._stop = threading.Event()
        self._frame = None
        self._number = 0
        self._frame_times = deque(maxlen=45)
        self._time = None
        self.error = None

    def start(self):
        if self._thread is not None:
            return
        self._thread = threading.Thread(target=self._run, daemon=True, name="camera")
        self._thread.start()

    def stop(self):
        self._stop.set()
        with self._condition:
            self._condition.notify_all()
        if self._thread is not None:
            self._thread.join(timeout=3)

    @staticmethod
    def _jpeg(image: Image.Image) -> bytes:
        buffer = BytesIO()
        image.save(buffer, format="JPEG", quality=75)
        return buffer.getvalue()

    def _publish(self, frame: bytes):
        with self._condition:
            self._frame = frame
            self._number += 1
            self._time = time.monotonic()
            self._frame_times.append(self._time)
            self._condition.notify_all()

    def _run(self):
        try:
            if self.demo:
                self._run_demo()
            else:
                self._run_pi()
        except Exception as exc:
            with self._condition:
                self.error = f"Kamera nicht verfügbar: {type(exc).__name__}: {exc}"
                self._condition.notify_all()

    def _run_demo(self):
        while not self._stop.is_set():
            image = Image.new("RGB", (640, 480), (21, 28, 32))
            draw = ImageDraw.Draw(image)
            draw.rectangle((40, 105, 600, 400), outline=(144, 111, 65), width=8)
            draw.ellipse((165, 205, 475, 340), fill=(45, 52, 36), outline=(110, 91, 59), width=4)
            draw.text((42, 30), "DEMO - KEINE ECHTE KAMERA", fill=(255, 172, 72))
            draw.text((42, 440), datetime.now().strftime("%Y-%m-%d %H:%M:%S"), fill="white")
            self._publish(self._jpeg(image))
            self._stop.wait(0.2)

    def _run_pi(self):
        from picamera2 import Picamera2

        camera = Picamera2()
        started = False
        try:
            # BGR888 liefert laut Picamera2-Dokumentation RGB-Arrays für PIL.
            config = camera.create_video_configuration(
                main={"size": (640, 480), "format": "BGR888"},
                controls={"FrameDurationLimits": (66667, 66667)}, queue=False
            )
            camera.configure(config)
            camera.start()
            started = True
            while not self._stop.is_set():
                began = time.monotonic()
                pixels = camera.capture_array("main")
                self._publish(self._jpeg(Image.fromarray(pixels, "RGB")))
                self._stop.wait(max(0., 1/self.TARGET_FPS-(time.monotonic()-began)))
        finally:
            try:
                if started:
                    camera.stop()
            finally:
                camera.close()

    def latest(self):
        with self._condition:
            return self._frame

    def latest_numbered(self):
        with self._condition:
            return self._number, self._frame

    def latest_timed(self):
        with self._condition:
            return self._number, self._frame, self._time

    def wait_next(self, number: int, timeout: float = 10):
        with self._condition:
            self._condition.wait_for(
                lambda: self._number > number or self.error or self._stop.is_set(),
                timeout=timeout,
            )
            return self._number, self._frame

    def status(self):
        with self._condition:
            age = None if self._time is None else round(time.monotonic() - self._time, 1)
            times = self._frame_times
            fps = ((len(times)-1)/(times[-1]-times[0])
                   if len(times)>1 and times[-1]>times[0] and age is not None and age<1 else 0.)
            return {
                "fps": round(fps, 1),
                "target_fps": 5 if self.demo else self.TARGET_FPS,
                "source": "Demo" if self.demo else "Pi-Kamera",
                "ready": self._frame is not None and age is not None and age < 3,
                "frame_age_seconds": age,
                "error": self.error,
            }