ForcePilot/backend/package/yuxi/channel/extensions/qqbot/status.py

from __future__ import annotations

import logging
import time

from yuxi.channel.extensions.qqbot.types import QQBotAccountConfig
from yuxi.channel.protocols import ChannelAccountSnapshot

logger = logging.getLogger(__name__)


class QQBotStatusAdapter:
    def __init__(self, account_id: str = "default"):
        self._account_id = account_id
        self._connected = False
        self._last_connected_at: float | None = None
        self._last_error: str | None = None
        self._running = False
        self._token_source: str | None = None

    @property
    def connected(self) -> bool:
        return self._connected

    @connected.setter
    def connected(self, value: bool) -> None:
        self._connected = value
        if value:
            self._last_connected_at = time.time()

    @property
    def last_connected_at(self) -> float | None:
        return self._last_connected_at

    @property
    def last_error(self) -> str | None:
        return self._last_error

    @last_error.setter
    def last_error(self, value: str | None) -> None:
        self._last_error = value

    @property
    def running(self) -> bool:
        return self._running

    @running.setter
    def running(self, value: bool) -> None:
        self._running = value

    @property
    def token_source(self) -> str | None:
        return self._token_source

    @token_source.setter
    def token_source(self, value: str | None) -> None:
        self._token_source = value

    async def probe(self, account: dict | None = None) -> bool:
        return self._connected

    def build_summary(self, snapshot: object) -> dict:
        return {
            "connected": self._connected,
            "running": self._running,
            "last_connected_at": self._last_connected_at,
            "last_error": self._last_error,
        }

    def build_channel_summary(
        self,
        account: dict,
        config: dict,
        default_account_id: str,
        snapshot: ChannelAccountSnapshot,
    ) -> dict:
        return {
            "configured": True,
            "token_source": self._token_source or "unknown",
            "running": self._running,
            "connected": self._connected,
            "last_connected_at": self._last_connected_at,
            "last_error": self._last_error,
        }

    def build_account_snapshot(
        self,
        account: dict,
        config: dict,
        runtime: ChannelAccountSnapshot | None = None,
        probe: object | None = None,
        audit: object | None = None,
    ) -> ChannelAccountSnapshot:
        return ChannelAccountSnapshot(
            account_id=self._account_id,
            channel_type="qqbot",
            configured=True,
            running=self._running,
            connected=self._connected,
            last_connected_at=self._last_connected_at,
            last_error=self._last_error,
        )