// UiCommunicationBus.cpp
#include "uiCommunicationBus.h"
#include "communicationManager.h"
#include "dataProcessor.h"
#include <QJsonDocument>
#include <QDebug>
#include <QJsonObject>
#include <QJsonArray>

UiCommunicationBus* UiCommunicationBus::instance()
{
    static UiCommunicationBus* instance = nullptr;
    static QMutex mutex;

    if (!instance) {
        QMutexLocker locker(&mutex);
        if (!instance) {
            instance = new UiCommunicationBus;
        }
    }
    return instance;
}

UiCommunicationBus::UiCommunicationBus(QObject* parent)
    : QObject(parent)
{
    // 连接到CommunicationManager
    CommunicationManager* comm = CommunicationManager::instance();

    // 连接HTTP信号
    connect(comm, &CommunicationManager::httpDataReceived,
            this, &UiCommunicationBus::onHttpDataReceived);

    // 连接WebSocket信号
    connect(comm, &CommunicationManager::websocketDataReceived,
            this, &UiCommunicationBus::onWebSocketDataReceived);

    // 连接DataProcessor信号
    DataProcessor* processor = DataProcessor::instance();
    connect(processor, &DataProcessor::httpProcessed,
            this, [this](const QString& dataType, const QVariant& data) {
                if(dataType == "recommend"){
                    // 推荐列表请求将数据分发回订阅ui
                    broadcastToUis(dataType, data);
                }
                emit httpDataProcessed(dataType,data);
            });

    connect(processor, &DataProcessor::websocketProcessed,
            this, [this](const QVariant& data) {
                emit websocketDataProcessed(data);
            });

    qDebug() << "UiCommunicationBus initialized";
}

void UiCommunicationBus::sendHttpRequest(const QString& endpoint, const QVariant& data)
{
    CommunicationManager* comm = CommunicationManager::instance();

    QJsonDocument doc = QJsonDocument::fromVariant(data);
    bool success = comm->sendHttpRequest(endpoint, doc.toJson());

    if (success) {
        qDebug() << "HTTP请求已发送:" << endpoint;
    } else {
        qWarning() << "HTTP请求发送失败:" << endpoint;
    }
}

void UiCommunicationBus::sendHttpRequestNoReply(const QString& endpoint, const QVariant& data)
{
    CommunicationManager* comm = CommunicationManager::instance();

    QJsonDocument doc = QJsonDocument::fromVariant(data);
    comm->sendHttpRequest(endpoint, doc.toJson());

    qDebug() << "无回复HTTP请求已发送:" << endpoint;
}

void UiCommunicationBus::onHttpDataReceived(const QByteArray& data)
{
    QJsonParseError error;
    QJsonDocument doc = QJsonDocument::fromJson(data, &error);

    if (error.error != QJsonParseError::NoError) {
        qWarning() << "HTTP响应解析失败:" << error.errorString();
        return;
    }

    QVariant response = doc.toVariant();

    if (response.typeId() == QMetaType::QVariantMap) {
        QVariantMap responseMap = response.toMap();
        DataProcessor* processor = DataProcessor::instance();

        QString state = responseMap.value("msg").toString();
        if(state == "success"){
            if(responseMap.contains("payload")){
                processor->processData(responseMap.value("payload"));
            }
        }
    }

    qDebug() << "HTTP响应已处理";
}

void UiCommunicationBus::onWebSocketDataReceived(const QByteArray& data)
{
    QJsonParseError error;
    QJsonDocument doc = QJsonDocument::fromJson(data, &error);

    if (error.error != QJsonParseError::NoError) {
        qWarning() << "WebSocket数据解析失败:" << error.errorString();
        return;
    }

    QVariant response = doc.toVariant();

    if (response.typeId() == QMetaType::QVariantMap) {
        QVariantMap responseMap = response.toMap();
        DataProcessor* processor = DataProcessor::instance();

        QString state = responseMap.value("msg").toString();
        if(state == "success"){
            if(responseMap.contains("payload")){
                processor->processData(responseMap.value("payload"),1);
            }
        }
    }

    qDebug() << "WebSocket数据已处理";
}

void UiCommunicationBus::sendToUi(const QString& uiId, const QString& action, const QVariant& data)
{
    QMutexLocker locker(&m_mutex);

    if (!m_uiObjects.contains(uiId)) {
        qWarning() << "UI未注册:" << uiId;
        return;
    }

    QObject* uiObject = m_uiObjects[uiId];

    // 尝试调用通用的消息处理槽
    bool success = QMetaObject::invokeMethod(uiObject, "onMessage",
                                            Qt::QueuedConnection,
                                             Q_ARG(QString, action),
                                             Q_ARG(QVariant, data));

    if (!success) {
        qWarning() << "调用UI消息处理失败:" << uiId << "action:" << action;
    }
}

void UiCommunicationBus::broadcastToUis(const QString& action, const QVariant& data)
{
    QMutexLocker locker(&m_mutex);

    for (auto it = m_uiObjects.begin(); it != m_uiObjects.end(); ++it) {
        QObject* uiObject = it.value();

        QMetaObject::invokeMethod(uiObject, "onMessage",
                                  Q_ARG(QString, action),
                                  Q_ARG(QVariant, data));
    }

    qDebug() << "消息广播:" << action << "接收者:" << m_uiObjects.size();
}

void UiCommunicationBus::registerUi(const QString& uiId, QObject* uiObject)
{
    if (uiId.isEmpty() || !uiObject) {
        qWarning() << "注册UI失败: 参数无效";
        return;
    }

    QMutexLocker locker(&m_mutex);
    m_uiObjects[uiId] = uiObject;
    qDebug() << "UI已注册:" << uiId;
}

void UiCommunicationBus::unregisterUi(const QString& uiId)
{
    QMutexLocker locker(&m_mutex);
    m_uiObjects.remove(uiId);
    qDebug() << "UI已注销:" << uiId;
}