#include "device_bus/manager/DeviceBusManager.h"

#include <QJsonDocument>
#include <algorithm>

#include "hardware/drivers/serial/SerialCapabilities.h"
#include "core/device/DeviceTypes.h"
#include "utils/logs/logging.h"

using softbus::hardware::drivers::serial::SerialQtDriver;
namespace serial_cap = softbus::hardware::drivers::serial::capabilities;

bool DeviceBusManager::initialize(const QJsonObject& rootConfig)
{
    // 加载设备树
    QString treeError;
    if (!m_treeModel.loadFromDaemonConfig(rootConfig, &treeError)) {
        LOG_ERROR() << "DeviceBusManager: failed to load device_tree:" << treeError;
        return false;
    }

    const auto nodes = m_treeModel.nodes();
    for (const auto& n : nodes) {
        if (!n.enabled) continue;
        auto kind = softbus::core::device::kindFromType(n.type);
        if (kind == softbus::core::device::DeviceKind::Unknown) {
            kind = softbus::core::device::inferDeviceKindFromEndpoint(n.endpoint);
        }

        if (kind == softbus::core::device::DeviceKind::Serial) {
            initializeSerialDriver(n.endpoint, n.params);
            m_deviceEndpointsMap.insert(n.endpoint, QStringLiteral("serial"));
        } else {
            LOG_WARNING() << "DeviceBusManager: skip unsupported kind for endpoint=" << n.endpoint
                          << "type=" << n.type;
        }
    }

    return true;
}

void DeviceBusManager::shutdown()
{
    // 关闭并销毁所有串口驱动
    const auto keys = m_serialDriversMap.keys();
    for (const auto& endpoint : keys) {
        shutdownSerialDriver(endpoint);
    }
}

void DeviceBusManager::initializeSerialDriver(const QString& endpoint,const QJsonObject& params)
{
    if (m_serialDriversMap.contains(endpoint)) {
        LOG_WARNING() << "DeviceBusManager: serial driver already exists for" << endpoint;
        return;
    }

    // 合并参数（defaults + enum 校验）
    serial_cap::SerialDefaults def = serial_cap::kDefaults;

    int baud = params.value(QStringLiteral("baudRate")).toInt(def.baudRate);
    if (!serial_cap::isValidBaud(baud)) baud = def.baudRate;

    int dataBits = params.value(QStringLiteral("dataBits")).toInt(def.dataBits);
    if (!serial_cap::isValidDataBits(dataBits)) dataBits = def.dataBits;

    QString parityStr = params.value(QStringLiteral("parity")).toString(QLatin1String(def.parity));
    if (!serial_cap::isValidParity(parityStr)) parityStr = QLatin1String(def.parity);

    int stopBitsVal = params.value(QStringLiteral("stopBits")).toInt(def.stopBits);
    if (!serial_cap::isValidStopBits(stopBitsVal)) stopBitsVal = def.stopBits;

    QString flowStr = params.value(QStringLiteral("flowControl")).toString(QLatin1String(def.flowControl));
    if (!serial_cap::isValidFlowControl(flowStr)) flowStr = QLatin1String(def.flowControl);

    QJsonObject merged;
    merged.insert(QStringLiteral("baudRate"), baud);
    merged.insert(QStringLiteral("dataBits"), dataBits);
    merged.insert(QStringLiteral("parity"), parityStr);
    merged.insert(QStringLiteral("stopBits"), stopBitsVal);
    merged.insert(QStringLiteral("flowControl"), flowStr);

    LOG_INFO() << "DeviceBusManager: init serial endpoint=" << endpoint
               << "params=" << QJsonDocument(merged).toJson(QJsonDocument::Compact);

    auto driver = new SerialQtDriver(nullptr);
    driver->SetBaudRate(static_cast<QSerialPort::BaudRate>(baud));
    driver->SetDataBits(static_cast<QSerialPort::DataBits>(dataBits));

    QSerialPort::Parity parity = QSerialPort::NoParity;
    if (parityStr == QStringLiteral("even")) {
        parity = QSerialPort::EvenParity;
    } else if (parityStr == QStringLiteral("odd")) {
        parity = QSerialPort::OddParity;
    }
    driver->SetParity(parity);

    QSerialPort::StopBits stopBits = (stopBitsVal == 2) ? QSerialPort::TwoStop : QSerialPort::OneStop;
    driver->SetStopBits(stopBits);

    QSerialPort::FlowControl flow = QSerialPort::NoFlowControl;
    if (flowStr == QStringLiteral("hardware")) {
        flow = QSerialPort::HardwareControl;
    } else if (flowStr == QStringLiteral("software")) {
        flow = QSerialPort::SoftwareControl;
    }
    driver->SetFlowControl(flow);

    // 按你当前策略：初始化时就打开串口
    driver->Open(endpoint.toStdString());

    m_serialDriversMap.insert(endpoint, driver);
    m_serialDriversList.push_back(driver);
}

void DeviceBusManager::shutdownSerialDriver(const QString& endpoint)
{
    auto driver = m_serialDriversMap.take(endpoint);
    if (driver) {
        driver->Close();
        delete driver;
        m_serialDriversList.removeAll(driver);
    }
}