"""后台 Agent 主循环（QThread）。"""

from __future__ import annotations

import logging
import threading

from PyQt6.QtCore import QThread, pyqtSignal

from app.config_store import AgentSettings
from app.engine_path import ensure_runtime_importable
from app.oms_agent_runner import run_agent_loop
from app.oms_client import OmsAgentClient

logger = logging.getLogger(__name__)


class AgentWorker(QThread):
    log_line = pyqtSignal(str)
    status_changed = pyqtSignal(dict)
    started_ok = pyqtSignal(dict)
    stopped = pyqtSignal()
    failed = pyqtSignal(str)

    def __init__(self, settings: AgentSettings, parent=None) -> None:
        super().__init__(parent)
        self._settings = settings
        self._stop_event = threading.Event()

    def request_stop(self) -> None:
        self._stop_event.set()

    def run(self) -> None:
        try:
            ensure_runtime_importable()

            from xhs_bridge.service import XhsBridgeService

            svc = XhsBridgeService()
            device_id = svc.license.device_id
            client = OmsAgentClient(
                self._settings.oms_url.strip(),
                self._settings.token.strip(),
                device_id,
            )

            self.started_ok.emit(
                {
                    "device_id": device_id,
                    "agent_id": client.agent_id,
                    "bridge_port": self._settings.bridge_port,
                }
            )
            self.log_line.emit(f"已连接 OMS：{self._settings.oms_url}")
            self.log_line.emit(f"设备 ID：{device_id}")

            def stop_flag() -> bool:
                return self._stop_event.is_set()

            import app.oms_agent_runner as runner

            orig_heartbeat = runner._heartbeat

            def wrapped_heartbeat(c, s):
                orig_heartbeat(c, s)
                try:
                    st = s.status()
                    self.status_changed.emit(
                        {
                            "engine_running": bool(st.get("bridge_running")),
                            "extension_connected": bool(st.get("extension_connected")),
                            "xhs_logged_in": bool(st.get("login_ok")),
                        }
                    )
                except Exception:
                    pass
                self.log_line.emit("心跳 OK")

            runner._heartbeat = wrapped_heartbeat

            run_agent_loop(
                client,
                svc,
                device_name=self._settings.device_name or None,
                bridge_port=self._settings.bridge_port,
                stop_flag=stop_flag,
            )
        except Exception as exc:
            logger.exception("Agent 线程异常")
            self.failed.emit(str(exc))
        finally:
            self.stopped.emit()