soft_bus/src/daemon/daemon_service.cpp

/**
 * @file daemon_service.cpp
 * @brief D-Bus 服务实现
 */

#include "daemon_service.h"
#include "core/CoreService.h"
#include "soft_bus_core/soft_bus_core.h"
#include "api/SoftBusAPI.h"
#include "manage_serial/serial_manager.h"
#include "can_manager/can_manager.h"
#include <QCoreApplication>
#include <QDBusConnection>
#include <QDateTime>
#include "utils/logging.h"
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QTimer>
#include <QSerialPortInfo>
#include <QSerialPort>
#include <QByteArray>
#include <QSet>
#include <unistd.h>

DaemonService::DaemonService(CoreService* coreService, QObject* parent)
    : QObject(parent)
    , m_coreService(coreService)
    , m_loadInfoTimer(nullptr)
    , m_totalMessagesProcessed(0)
    , m_lastMessageCount(0)
{
    initializeLoadInfo();
    
    // 定时更新负载信息（每5秒）
    m_loadInfoTimer = new QTimer(this);
    connect(m_loadInfoTimer, &QTimer::timeout, this, &DaemonService::updateLoadInfo);
    m_loadInfoTimer->start(5000);
    
    updateLoadInfo(); // 立即更新一次
    
    // 延迟连接硬件资源信号（确保 SoftBusAPI 已初始化）
    QTimer::singleShot(100, this, [this]() {
        SoftBusAPI* api = SoftBusAPI::instance();
        if (api && api->isInitialized()) {
            // 连接串口信号（使用队列连接确保线程安全）
            connect(api, &SoftBusAPI::serialDataReceived,
                    this, [this](const QString& portName, const QByteArray& data) {
                        QString base64Data = QString::fromUtf8(data.toBase64());
                        emit serialDataReceived(portName, base64Data);
                    }, Qt::QueuedConnection);
            
            // 连接CAN信号（使用队列连接确保线程安全）
            connect(api, &SoftBusAPI::canDataReceived,
                    this, [this](const QString& deviceName, int canPort, unsigned int canId,
                                 const QByteArray& data, bool isExtendedId) {
                        QString base64Data = QString::fromUtf8(data.toBase64());
                        emit canDataReceived(deviceName, canPort, canId, base64Data, isExtendedId);
                    }, Qt::QueuedConnection);
        }
    });
}

DaemonService::~DaemonService()
{
    if (m_loadInfoTimer) {
        m_loadInfoTimer->stop();
    }
}

bool DaemonService::isRunning() const
{
    return m_coreService && m_coreService->isInitialized();
}

QString DaemonService::getStatus() const
{
    QJsonObject status;
    
    if (!m_coreService || !m_coreService->isInitialized()) {
        status["running"] = false;
        status["status"] = "stopped";
    } else {
        status["running"] = true;
        status["status"] = "running";
        status["initialized"] = m_coreService->isInitialized();
        
        DeviceBusCore* busCore = m_coreService->getDeviceBusCore();
        if (busCore) {
            QList<DeviceInfo> devices = busCore->getAllDevices();
            status["deviceCount"] = devices.size();
            
            int onlineCount = 0;
            for (const auto& device : devices) {
                if (device.status == "online" && device.isActive) {
                    onlineCount++;
                }
            }
            status["onlineDeviceCount"] = onlineCount;
        }
    }
    
    // 添加客户端列表
    QJsonArray clientsArray;
    for (const QString& id : m_registeredClients) {
        clientsArray.append(id);
    }
    status["clients"] = clientsArray;
    
    return QJsonDocument(status).toJson(QJsonDocument::Compact);
}

QString DaemonService::getLoadInfo() const
{
    QJsonObject loadInfo;
    
    if (!m_coreService || !m_coreService->isInitialized()) {
        loadInfo["cpuUsage"] = 0.0;
        loadInfo["memoryUsage"] = 0.0;
        loadInfo["messageRate"] = 0.0;
        return QJsonDocument(loadInfo).toJson(QJsonDocument::Compact);
    }
    
    // 计算消息处理速率（每秒处理的消息数）
    qint64 elapsed = m_lastUpdateTime.msecsTo(QDateTime::currentDateTime());
    double messageRate = 0.0;
    if (elapsed > 0) {
        qint64 messageDelta = m_totalMessagesProcessed - m_lastMessageCount;
        messageRate = (messageDelta * 1000.0) / elapsed;
    }
    
    loadInfo["messageRate"] = messageRate;
    loadInfo["totalMessagesProcessed"] = m_totalMessagesProcessed;
    loadInfo["timestamp"] = QDateTime::currentDateTime().toString(Qt::ISODate);
    
    // TODO: 添加实际的 CPU 和内存使用率监控
    // 可以使用 QProcess 调用系统命令或使用系统 API
    loadInfo["cpuUsage"] = 0.0;  // 占位符
    loadInfo["memoryUsage"] = 0.0;  // 占位符
    
    return QJsonDocument(loadInfo).toJson(QJsonDocument::Compact);
}

int DaemonService::getDeviceCount() const
{
    if (!m_coreService || !m_coreService->isInitialized()) {
        return 0;
    }
    
    DeviceBusCore* busCore = m_coreService->getDeviceBusCore();
    if (!busCore) {
        return 0;
    }
    
    return busCore->getAllDevices().size();
}

QString DaemonService::getAllDevices() const
{
    QJsonArray devicesArray;
    
    if (!m_coreService || !m_coreService->isInitialized()) {
        QJsonObject result;
        result["devices"] = devicesArray;
        return QJsonDocument(result).toJson(QJsonDocument::Compact);
    }
    
    DeviceBusCore* busCore = m_coreService->getDeviceBusCore();
    if (!busCore) {
        QJsonObject result;
        result["devices"] = devicesArray;
        return QJsonDocument(result).toJson(QJsonDocument::Compact);
    }
    
    QList<DeviceInfo> devices = busCore->getAllDevices();
    for (const DeviceInfo& device : devices) {
        QJsonObject deviceObj;
        deviceObj["id"] = device.id;
        deviceObj["portname"] = device.portname;
        deviceObj["name"] = device.name;
        deviceObj["type"] = device.type;
        deviceObj["address"] = device.address;
        deviceObj["protocol"] = device.protocol;
        deviceObj["protocol_detail"] = device.protocol_detail;
        deviceObj["status"] = device.status;
        deviceObj["isActive"] = device.isActive;
        if (device.lastSeen.isValid()) {
            deviceObj["lastSeen"] = device.lastSeen.toString(Qt::ISODate);
        }
        deviceObj["properties"] = device.properties;
        devicesArray.append(deviceObj);
    }
    
    QJsonObject result;
    result["devices"] = devicesArray;
    return QJsonDocument(result).toJson(QJsonDocument::Compact);
}

QString DaemonService::getMessageStats() const
{
    QJsonObject stats;
    
    if (!m_coreService || !m_coreService->isInitialized()) {
        stats["totalMessages"] = 0;
        stats["messageRate"] = 0.0;
        return QJsonDocument(stats).toJson(QJsonDocument::Compact);
    }
    
    qint64 elapsed = m_lastUpdateTime.msecsTo(QDateTime::currentDateTime());
    double messageRate = 0.0;
    if (elapsed > 0) {
        qint64 messageDelta = m_totalMessagesProcessed - m_lastMessageCount;
        messageRate = (messageDelta * 1000.0) / elapsed;
    }
    
    stats["totalMessages"] = m_totalMessagesProcessed;
    stats["messageRate"] = messageRate;
    stats["lastUpdateTime"] = m_lastUpdateTime.toString(Qt::ISODate);
    
    return QJsonDocument(stats).toJson(QJsonDocument::Compact);
}

qint64 DaemonService::getPid() const
{
    return static_cast<qint64>(getpid());
}

void DaemonService::shutdown()
{
    LOG_DEBUG() << "DaemonService shutdown requested";
    emit statusChanged("", "shutting_down");  // 空字符串表示系统状态
    
    if (m_loadInfoTimer) {
        m_loadInfoTimer->stop();
    }
    
    QCoreApplication::quit();
}

bool DaemonService::registerClient(const QString& clientId)
{
    if (clientId.isEmpty()) {
        return false;
    }
    
    m_registeredClients.insert(clientId);
    LOG_INFO() << "Client registered:" << clientId << "Total clients:" << m_registeredClients.size();
    
    // 通知所有客户端有新客户端注册（发送包含所有客户端列表的状态）
    QString statusJson = getStatus();
    QJsonDocument doc = QJsonDocument::fromJson(statusJson.toUtf8());
    if (doc.isObject()) {
        QJsonObject obj = doc.object();
        QJsonArray clientsArray;
        for (const QString& id : m_registeredClients) {
            clientsArray.append(id);
        }
        obj["clients"] = clientsArray;
        statusJson = QJsonDocument(obj).toJson(QJsonDocument::Compact);
    }
    
    // 广播给所有客户端（空字符串表示系统状态变化）
    emit statusChanged("", statusJson);
    
    return true;
}

void DaemonService::unregisterClient(const QString& clientId)
{
    if (m_registeredClients.remove(clientId)) {
        LOG_INFO() << "Client unregistered:" << clientId << "Remaining clients:" << m_registeredClients.size();
        
        // 通知所有客户端有客户端注销
        QString statusJson = getStatus();
        QJsonDocument doc = QJsonDocument::fromJson(statusJson.toUtf8());
        if (doc.isObject()) {
            QJsonObject obj = doc.object();
            QJsonArray clientsArray;
            for (const QString& id : m_registeredClients) {
                clientsArray.append(id);
            }
            obj["clients"] = clientsArray;
            statusJson = QJsonDocument(obj).toJson(QJsonDocument::Compact);
        }
        
        // 广播给所有客户端
        emit statusChanged("", statusJson);
    }
}

QString DaemonService::getRegisteredClients() const
{
    QJsonArray clientsArray;
    for (const QString& id : m_registeredClients) {
        clientsArray.append(id);
    }
    
    QJsonObject result;
    result["clients"] = clientsArray;
    return QJsonDocument(result).toJson(QJsonDocument::Compact);
}

void DaemonService::updateLoadInfo()
{
    // 更新消息计数（这里需要从实际的消息处理中获取）
    // 目前使用占位符，实际应该从 DeviceBusCore 或消息处理模块获取
    
    // 发出负载信息更新信号（空字符串表示系统更新，所有客户端都会收到）
    emit loadInfoUpdated("", getLoadInfo());
    
    // 更新统计时间
    m_lastMessageCount = m_totalMessagesProcessed;
    m_lastUpdateTime = QDateTime::currentDateTime();
}

void DaemonService::initializeLoadInfo()
{
    m_totalMessagesProcessed = 0;
    m_lastMessageCount = 0;
    m_lastUpdateTime = QDateTime::currentDateTime();
}

// ========== 硬件资源管理接口实现 ==========
bool DaemonService::openSerialPort(const QString& portName, int baudRate, int dataBits,
                                    int parity, int stopBits, int flowControl)
{
    if (!m_coreService || !m_coreService->isInitialized()) {
        return false;
    }
    
    SoftBusAPI* api = SoftBusAPI::instance();
    if (!api || !api->isInitialized()) {
        LOG_WARNING() << "SoftBusAPI not initialized";
        return false;
    }
    
    // 查找串口信息
    QList<QSerialPortInfo> ports = QSerialPortInfo::availablePorts();
    for (const QSerialPortInfo& info : ports) {
        if (info.portName() == portName) {
            // 设置串口配置
            SerialManager::SerialConfig config;
            config.baudRate = static_cast<QSerialPort::BaudRate>(baudRate);
            config.dataBits = static_cast<QSerialPort::DataBits>(dataBits);
            config.parity = static_cast<QSerialPort::Parity>(parity);
            config.stopBits = static_cast<QSerialPort::StopBits>(stopBits);
            config.flowControl = static_cast<QSerialPort::FlowControl>(flowControl);
            api->setSerialConfig(config);
            
            // 打开串口
            bool success = api->openSerialPort(info);
            if (success) {
                emit serialPortStatusChanged(portName, true);
            }
            return success;
        }
    }
    
    LOG_WARNING() << "Serial port not found:" << portName;
    return false;
}

void DaemonService::closeSerialPort(const QString& portName)
{
    SoftBusAPI* api = SoftBusAPI::instance();
    if (api && api->isInitialized()) {
        api->closeSerialPort(portName);
        emit serialPortStatusChanged(portName, false);
    }
}

QString DaemonService::getOpenedSerialPorts() const
{
    QJsonArray ports;
    
    SoftBusAPI* api = SoftBusAPI::instance();
    if (api && api->isInitialized()) {
        QStringList portList = api->getOpenedSerialPorts();
        for (const QString& port : portList) {
            ports.append(port);
        }
    }
    
    QJsonObject result;
    result["ports"] = ports;
    return QJsonDocument(result).toJson(QJsonDocument::Compact);
}

QString DaemonService::getAvailableSerialPorts() const
{
    QJsonArray ports;
    
    SoftBusAPI* api = SoftBusAPI::instance();
    if (api && api->isInitialized()) {
        QStringList portList = api->getAvailableSerialPorts();
        for (const QString& port : portList) {
            ports.append(port);
        }
    }
    
    QJsonObject result;
    result["ports"] = ports;
    return QJsonDocument(result).toJson(QJsonDocument::Compact);
}

bool DaemonService::writeSerialData(const QString& portName, const QString& data)
{
    SoftBusAPI* api = SoftBusAPI::instance();
    if (!api || !api->isInitialized()) {
        return false;
    }
    
    // Base64 解码
    QByteArray byteData = QByteArray::fromBase64(data.toUtf8());
    return api->sendSerialData(portName, byteData);
}

bool DaemonService::openCanDevice(int comPort, int baudRate)
{
    if (!m_coreService || !m_coreService->isInitialized()) {
        return false;
    }
    
    SoftBusAPI* api = SoftBusAPI::instance();
    if (!api || !api->isInitialized()) {
        LOG_WARNING() << "SoftBusAPI not initialized";
        return false;
    }
    
    bool success = api->openCanDevice(comPort);
    if (success) {
        QString deviceName = QString("CAN_%1").arg(comPort);
        emit canDeviceStatusChanged(deviceName, true);
    }
    return success;
}

void DaemonService::closeCanDevice(const QString& deviceName)
{
    SoftBusAPI* api = SoftBusAPI::instance();
    if (api && api->isInitialized()) {
        api->closeCanDevice(deviceName);
        emit canDeviceStatusChanged(deviceName, false);
    }
}

QString DaemonService::getOpenedCanDevices() const
{
    QJsonArray devices;
    
    SoftBusAPI* api = SoftBusAPI::instance();
    if (api && api->isInitialized()) {
        QStringList deviceList = api->getOpenedCanDevices();
        for (const QString& device : deviceList) {
            devices.append(device);
        }
    }
    
    QJsonObject result;
    result["devices"] = devices;
    return QJsonDocument(result).toJson(QJsonDocument::Compact);
}

QString DaemonService::getAvailableCanDevices() const
{
    QJsonArray devices;
    
    SoftBusAPI* api = SoftBusAPI::instance();
    if (api && api->isInitialized()) {
        QList<int> deviceList = api->getAvailableCanDevices();
        for (int comPort : deviceList) {
            devices.append(comPort);
        }
    }
    
    QJsonObject result;
    result["devices"] = devices;
    return QJsonDocument(result).toJson(QJsonDocument::Compact);
}

bool DaemonService::sendCanData(const QString& deviceName, int canPort, unsigned int canId,
                                 const QString& data, bool isExtendedId)
{
    SoftBusAPI* api = SoftBusAPI::instance();
    if (!api || !api->isInitialized()) {
        return false;
    }
    
    // Base64 解码
    QByteArray byteData = QByteArray::fromBase64(data.toUtf8());
    return api->sendCanData(deviceName, canPort, canId, byteData, isExtendedId);
}