"""Qt worker objects for non-blocking model generation and approval."""

from __future__ import annotations

import threading

from PySide6.QtCore import QObject, Signal, Slot

from javis.core.provider_router import ApprovalChoice
from javis.security.privacy import PrivacyDecision
from javis.ui.chat_controller import DesktopController


class ApprovalBridge(QObject):
    approval_requested = Signal(object)
    notice_received = Signal(str)

    def __init__(self) -> None:
        super().__init__()
        self._lock = threading.Lock()
        self._event: threading.Event | None = None
        self._result = ApprovalChoice.CANCEL

    def request(self, decision: PrivacyDecision) -> ApprovalChoice:
        event = threading.Event()
        with self._lock:
            self._event = event
            self._result = ApprovalChoice.CANCEL
        self.approval_requested.emit(decision)
        event.wait()
        with self._lock:
            result = self._result
            self._event = None
        return result

    def resolve(self, choice: ApprovalChoice) -> None:
        with self._lock:
            self._result = choice
            event = self._event
        if event is not None:
            event.set()

    def cancel_pending(self) -> None:
        self.resolve(ApprovalChoice.CANCEL)


class StreamWorker(QObject):
    event_received = Signal(object)
    completed = Signal()

    def __init__(self, controller: DesktopController, text: str) -> None:
        super().__init__()
        self._controller = controller
        self._text = text
        self._cancel_event = threading.Event()

    @Slot()
    def run(self) -> None:
        try:
            for event in self._controller.stream_message(
                self._text,
                self._cancel_event,
            ):
                self.event_received.emit(event)
        finally:
            self.completed.emit()

    def request_cancel(self) -> None:
        self._cancel_event.set()