"""
AI Box Sophon Adapter — MQTT 心跳上报处理器

监听 MQTT 主题 /board_ping（通过 MQTT Bridge 路由到 chongming/aibox_sophon_adapter/board_ping），
解析设备心跳数据并更新数据库记录。
"""
import json
import logging
from datetime import datetime

from chongming_worker import rpc_method
from ..models.board_models import BoardPingRequest

logger = logging.getLogger(__name__)


@rpc_method(
    subject="aibox_sophon_adapter.board_ping",
    method="MQTT",
    summary="AI Box 设备心跳上报",
    request_model=BoardPingRequest,
)
async def board_ping(request: BoardPingRequest, worker_id: str = "") -> dict:
    """
    处理设备心跳上报

    设备通过 MQTT 主题 /board_ping 定期（默认 5 秒）上报系统状态。
    收到心跳后更新数据库中的设备记录，标记为在线。
    """
    from ..global_var import db, heartbeat_timeout, stream_manager, link_path

    board_id = request.BoardId

    try:
        if db is None:
            raise RuntimeError("Database not initialized")
        async with db.get_session() as session:
            from ..models.orm import BoardHeartbeat
            from sqlalchemy import select

            stmt = select(BoardHeartbeat).where(BoardHeartbeat.board_id == board_id) # type: ignore
            result = await session.execute(stmt)
            record: BoardHeartbeat | None = result.scalar_one_or_none()

            now = datetime.now()
            ping_json = request.model_dump_json()

            if record is None:
                # 新设备，创建记录
                record = BoardHeartbeat(
                    board_id=board_id,
                    board_ip=request.BoardIp,
                    board_platform=request.BoardPlatform,
                    board_temp=request.BoardTemp,
                    board_type=request.BoardType,
                    status=request.Status,
                    version=request.Version,
                    system_info=request.System,
                    grant_code=request.GrantCode,
                    grant_desc=request.GrantDesc,
                    last_ping_time=now,
                    ping_data=ping_json,
                    is_online=True,
                )
                session.add(record)
                logger.info(f"[Heartbeat] 新设备上线: {board_id} (IP: {request.BoardIp})")
            else:
                # 已有设备，更新心跳
                record.board_ip = request.BoardIp
                record.board_platform = request.BoardPlatform
                record.board_temp = request.BoardTemp
                record.board_type = request.BoardType
                record.status = request.Status
                record.version = request.Version
                record.system_info = request.System
                record.grant_code = request.GrantCode
                record.grant_desc = request.GrantDesc
                record.last_ping_time = now
                record.ping_data = ping_json
                record.is_online = True
                record.updated_at = now

            await session.commit()

        if stream_manager is None:
            raise RuntimeError("StreamManager not initialized")
        
        ping_data = json.loads(ping_json)
        medias = ping_data.get("Medias", {})
        for media in medias:
            if "正常" in media.get("MediaStatus", {}).get("label", ""):
                stream_id = media["MediaName"]
                source_url = media["MediaUrl"].replace("/Link", link_path)
                await stream_manager.start_stream(f"/{stream_id}", source_url)

        logger.debug(
            f"[Heartbeat] {board_id}: temp={request.BoardTemp}, "
            f"disk={request.HostDisk.Used}/{request.HostDisk.Total} kB, "
            f"mem={request.HostMemory[0]:.1f} kB ({request.HostMemory[1]*100:.1f}%), "
            f"medias={len(request.Medias)}, tasks={len(request.Tasks)}"
        )

    except Exception as e:
        logger.error(f"[Heartbeat] 处理心跳失败 (board_id={board_id}): {e}")
        return {"error": str(e)}

    return {"received": True, "board_id": board_id}