"""Serve GUI snapshots and marshal browser controls onto the Qt thread."""

from __future__ import annotations

import base64
from collections.abc import Callable
from contextlib import suppress
import logging
import os
from pathlib import Path
import threading
import time
from typing import TYPE_CHECKING

import pyqtgraph as pg
from PyQt6.QtCore import QBuffer, QIODevice, QObject, pyqtSignal
from PyQt6.QtWidgets import QLineEdit, QSpinBox, QWidget

from python_app.gui.settings_defaults import env_enabled
from python_app.gui.controllers.config_controller import web_apply_field_names
from python_app.webui.controller import WebActionError

if TYPE_CHECKING:
    from python_app.gui.controllers.live_settings_controller import LiveSettingsController
    from python_app.gui.controllers.log_controller import LogController
    from python_app.gui.controllers.pipeline_controller import PipelineController
    from python_app.gui.controllers.preprocess_controller import PreprocessController
    from python_app.gui.controllers.profile_controller import ProfileController
    from python_app.gui.controllers.snapshot_controller import SnapshotController
    from python_app.webui.server import WebUiServer

logger = logging.getLogger(__name__)
_WEB_ACTION_TIMEOUT_S = 30.0
_GRAB_INTERVAL_S = 0.2
_LIVE_FIELD_NAMES = web_apply_field_names()


class _WebActionCall:
    """A timeout can cancel queued work; running work must never be retried blindly."""

    def __init__(self, action: Callable[[], object]) -> None:
        self.action = action
        self.done = threading.Event()
        self.error: str | None = None
        self._lock = threading.Lock()
        self._started = False

    def begin(self) -> bool:
        with self._lock:
            if self.done.is_set() or self._started:
                return False
            self._started = True
            return True

    def finish(self, error: str | None = None) -> None:
        with self._lock:
            if not self.done.is_set():
                self.error = error
                self.done.set()

    def cancel(self, error: str, *, queued_only: bool = True) -> bool:
        with self._lock:
            if self.done.is_set():
                return True
            if queued_only and self._started:
                return False
            self.error = error
            self.done.set()
            return True


def web_ui_port() -> int:
    try:
        port = int(os.environ.get("RADAR_SYSTEM_WEBUI_PORT", "8080"))
        return port if 1 <= port <= 65535 else 8080
    except ValueError:
        return 8080


class WebBridge(QObject):
    """Own web lifecycle, queued actions, immutable snapshots and change-gated PNGs."""

    _action_requested = pyqtSignal(object)
    _streaming_changed = pyqtSignal(bool)

    def __init__(
        self, parent: QWidget, run_configs_dir: Path, pipeline: PipelineController,
        preprocess: PreprocessController, snapshots: SnapshotController, profile: ProfileController,
        live: LiveSettingsController, log: LogController, *,
        save_path: QLineEdit, save_name: QLineEdit, record_count: QSpinBox,
    ) -> None:
        super().__init__(parent)
        self._parent, self._run_configs_dir = parent, run_configs_dir
        self._pipeline, self._preprocess, self._snapshots = pipeline, preprocess, snapshots
        self._profile, self._live, self._log = profile, live, log
        self._save_path, self._save_name, self._record_count = save_path, save_name, record_count
        self._server: WebUiServer | None = None
        self._status: dict = {}
        self._live_settings: list[dict] = []
        self._frame: dict | None = None
        self._pending_lock = threading.Lock()
        self._pending_calls: set[_WebActionCall] = set()
        self._closed = self._streaming = self._grabbing = False
        self._dirty = True
        self._last_png: str | None = None
        self._last_grab_s = 0.0
        self._frame_seq = self._snapshot_errors = 0
        self._action_requested.connect(self._run_action)
        self._streaming_changed.connect(self._set_streaming)
        plots = pipeline.plots
        plots.stack.currentChanged.connect(self._mark_dirty)
        for plot in plots.stack.findChildren(pg.PlotWidget):
            scene = plot.scene()
            assert scene is not None
            scene.changed.connect(self._mark_dirty)
            plot.sigDeviceRangeChanged.connect(self._mark_dirty)

    def start_server(self) -> None:
        if self._closed or self._server is not None:
            return
        try:
            from python_app.webui.server import WebUiServer

            if env_enabled("RADAR_SYSTEM_HEADLESS"):
                self._parent.resize(1600, 900)
            self._run_configs_dir.mkdir(parents=True, exist_ok=True)
            self.refresh_snapshot()
            self._server = WebUiServer(self, port=web_ui_port())
            self._server.start()
        except Exception:
            logger.warning("Failed to start web UI", exc_info=True)
            if self._server is not None:
                with suppress(Exception):
                    self._server.stop()
                self._server = None

    def shutdown(self) -> None:
        with self._pending_lock:
            self._closed, self._streaming = True, False
            pending = tuple(self._pending_calls)
        for call in pending:
            call.cancel("The application is closing", queued_only=False)
        if self._server is not None:
            with suppress(Exception):
                self._server.stop()
            self._server = None

    def _dispatch(self, action: Callable[[], object]) -> None:
        call = _WebActionCall(action)
        with self._pending_lock:
            if self._closed:
                raise WebActionError("The application is closing")
            self._pending_calls.add(call)
        try:
            self._action_requested.emit(call)
            if not call.done.wait(_WEB_ACTION_TIMEOUT_S):
                if not call.cancel("The desktop did not start the action in time; the request was cancelled"):
                    raise WebActionError("The desktop action is still running; check its status before retrying")
            if call.error is not None:
                raise WebActionError(call.error)
        finally:
            with self._pending_lock:
                self._pending_calls.discard(call)

    def _run_action(self, call: _WebActionCall) -> None:
        if self._closed or self._pipeline.closing:
            call.cancel("The application is closing", queued_only=False)
            return
        if not call.begin():
            return
        error = None
        try:
            with self._log.capture_errors() as captured:
                call.action()
            error = captured[0] if captured else None
            self.refresh_snapshot()
        except Exception as exc:
            error = self._log.exception_summary(exc)
        finally:
            call.finish(error)

    # The web thread reads only replaced snapshots; all widget reads happen below.
    def status(self) -> dict:
        return dict(self._status)

    def current_live_settings(self) -> list[dict]:
        return list(self._live_settings)

    def peek_frame(self) -> dict | None:
        return self._frame

    def list_configs(self) -> list[str]:
        return sorted(path.name for path in self._run_configs_dir.glob("*.json") if path.is_file())

    def start(self) -> None:
        self._dispatch(self._pipeline.start)

    def stop(self) -> None:
        self._dispatch(self._pipeline.stop)

    def single_capture(self) -> None:
        self._dispatch(lambda: self._pipeline.start(single_capture=True))

    def capture_tmp_reference(self) -> None:
        self._dispatch(self._preprocess.capture_tmp_reference)

    def remove_last_measurement(self) -> None:
        self._dispatch(lambda: self._snapshots.delete_history(remove_last=True))

    def clear_history(self) -> None:
        self._dispatch(lambda: self._snapshots.delete_history(remove_last=False))

    def start_recording(self, path: str, name: str, count: int) -> None:
        if type(count) is not int or count < 1:
            raise ValueError("Recording count must be a positive integer")
        self._dispatch(lambda: self._start_recording(path, name, count))

    def _start_recording(self, path: str, name: str, count: int) -> None:
        low, high = self._record_count.minimum(), self._record_count.maximum()
        if not low <= count <= high:
            raise ValueError(f"Recording count must be an integer from {low} to {high}")
        self._set_destination(path, name)
        self._record_count.setValue(count)
        self._snapshots.start_recording(count)

    def _set_destination(self, path: str, name: str) -> None:
        if path.strip():
            self._save_path.setText(path)
        self._save_name.setText(name)

    def save_dataset(self, path: str, name: str) -> None:
        self._dispatch(lambda: self._save_dataset(path, name))

    def _save_dataset(self, path: str, name: str) -> None:
        self._set_destination(path, name)
        self._snapshots.save()

    def load_config(self, name: str) -> None:
        def load() -> None:
            path = self._run_configs_dir / name
            if not name or name != Path(name).name or path.suffix.lower() != ".json" or not path.is_file():
                raise ValueError(f"Unknown run config: {name}")
            self._profile.load(path)
        self._dispatch(load)

    def apply_live_settings(self, fields: dict) -> list[dict]:
        fields = dict(fields)
        unknown = set(fields) - _LIVE_FIELD_NAMES
        if unknown:
            raise ValueError(f"Unknown live-settings fields: {', '.join(sorted(unknown))}")
        self._dispatch(lambda: self._live.apply_web(fields))
        return self.current_live_settings()

    def select_combo(self, input_pos: int, output_pos: int) -> None:
        if any(type(pos) is not int or pos < 0 for pos in (input_pos, output_pos)):
            raise ValueError("Channel positions must be nonnegative integers")
        self._dispatch(lambda: self._pipeline.plots.select_combo(input_pos, output_pos))

    def next_combo(self) -> None:
        self._dispatch(self._pipeline.plots.select_next_combo)

    def refresh_snapshot(self) -> None:
        if self._closed or self._pipeline.closing:
            return
        try:
            pipeline, plots = self._pipeline, self._pipeline.plots
            input_pos, output_pos = plots.display_key or (0, 0)
            mode = self._live.active_mode
            self._status = {
                "running": pipeline.running, "processor_running": pipeline.processor_running,
                "ring_name": self._profile.state.config.rings.results.name,
                "active_config": self._profile.state.path.name,
                "save_path": self._save_path.text(), "save_name": self._save_name.text(),
                "record_count": self._record_count.value(), "recording": pipeline.recording.status(),
                "raw_count": len(pipeline.history.raw), "preprocessed_count": len(pipeline.history.preprocessed),
                "result_count": len(pipeline.history.results),
                "sar3d_status": plots.sar3d.status_label.text() if mode == "sar3d" else "",
                "display_combo": {"enabled": mode == "bscan", "input": input_pos, "output": output_pos,
                                  "options": sorted(plots.bscan.history_by_combo)},
            }
            self._live_settings = self._live.config.web_schema()
            frame = self._grab_frame_if_due()
            if frame is not None:
                self._frame = frame
        except Exception:
            self._snapshot_errors += 1
            if self._snapshot_errors % 200 == 1:
                logger.warning("Web UI snapshot refresh failed", exc_info=True)

    def set_frame_streaming(self, enabled: bool) -> None:
        if not self._closed:
            self._streaming_changed.emit(enabled)

    def _set_streaming(self, enabled: bool) -> None:
        if not self._closed:
            self._streaming = enabled
            if enabled:
                self._dirty = True

    def _mark_dirty(self, *_args: object) -> None:
        if not self._closed and not self._grabbing:
            self._dirty = True

    def _grab_frame_if_due(self) -> dict | None:
        if self._closed or not self._streaming or not self._dirty:
            return None
        now = time.monotonic()
        if now - self._last_grab_s < _GRAB_INTERVAL_S:
            return None
        self._last_grab_s, self._dirty, self._grabbing = now, False, True
        try:
            png = self._grab_png()
        except Exception:
            self._dirty = True
            raise
        finally:
            self._grabbing = False
        if png is None or png == self._last_png:
            return None
        self._last_png = png
        self._frame_seq += 1
        return {"type": "frame", "seq": self._frame_seq, "mode": self._live.active_mode, "png_b64": png}

    def _grab_png(self) -> str | None:
        widget = self._pipeline.plots.capture_widget
        if widget is None or widget.width() <= 0 or widget.height() <= 0:
            return None
        pixmap = widget.grab()
        if pixmap.isNull():
            return None
        buffer = QBuffer()
        buffer.open(QIODevice.OpenModeFlag.WriteOnly)
        pixmap.save(buffer, "PNG")
        return base64.b64encode(buffer.data().data()).decode()