eUi/src/core/service/paramSyncManager.h

#pragma once
#include <nlohmannjson.hpp>
#include <QVariant>
#include <QMap>
#include <QMutex>
#include <QString>
#include <QMutexLocker>
#include <QDebug>
#include <vector>
#include <utility>

class paramSyncManager :public QObject{
    Q_OBJECT
public:
    // 构造函数：从JSON数据初始化参数
    explicit paramSyncManager(bSignalHub* _signalHub,const nlohmann::ordered_json& json = nlohmann::ordered_json::object()
    ):_signalHub(_signalHub){
        loadFromJson(json);
    }
    // 获取参数值，如果不存在则返回默认值
    QVariant get(QString name, QVariant defaultValue) {
        {
            QMutexLocker locker(&globalMutex);
            if (map.contains(name)) {
                return map[name];
            }
            map.insert(name, defaultValue);
        }
        
		emit _signalHub->saveMissionJson();
        return defaultValue;
    }
    
    // 编辑/设置参数值
    void edit(const QString& name, const QVariant& target) {

        if (map.contains(name)) {
            map[name] = target;
        }
        else {
            // 如果参数不存在，创建新的参数项
            map.insert(name, target);
        }
        emit _signalHub->saveMissionJson();
    }
    
    // 检查参数是否存在
    bool contains(const QString& name) const {
        QMutexLocker locker(&globalMutex);
        return map.contains(name);
    }
    
    // 移除参数
    bool remove(const QString& name) {
        QMutexLocker locker(&globalMutex);
        return map.remove(name) > 0;
    }
    
    // 获取所有参数名
    QStringList getParameterNames() const {
        QMutexLocker locker(&globalMutex);
        return map.keys();
    }

    //获取所有参数
    std::vector<std::pair<QString, QVariant>> getAllParams() {
        QMutexLocker locker(&globalMutex);
        std::vector<std::pair<QString, QVariant>> result;
        result.reserve(map.size());
        for (auto it = map.cbegin(); it != map.cend(); ++it) {
            result.emplace_back(it.key(), it.value());
        }
        return result;
    }
    
    // 从JSON加载数据
    void loadFromJson(const nlohmann::ordered_json& json) {
        QMutexLocker locker(&globalMutex);
        map.clear();
        
        if (!json.is_object()) {
            qDebug() << "Invalid JSON format for paramSyncManager";
            return;
        }
        
        for (auto it = json.begin(); it != json.end(); ++it) {
            QString key = QString::fromStdString(it.key());
            QVariant value = jsonToQVariant(it.value());
            
            map.insert(key, value);
        }
    }
    
    // 导出为JSON
    nlohmann::ordered_json toJson() const {
        QMutexLocker locker(&globalMutex);
        nlohmann::ordered_json result = nlohmann::ordered_json::object();
        
        for (auto it = map.begin(); it != map.end(); ++it) {
            result[it.key().toStdString()] = qVariantToJson(it.value());
        }
        
        return result;
    }
    
    // 清空所有参数
    void clear() {
        QMutexLocker locker(&globalMutex);
        map.clear();
    }

private:
    bSignalHub* _signalHub;
    QMap<QString, QVariant> map;
    mutable QMutex globalMutex;  // 保护整个map的全局互斥锁
    
    // 辅助方法：将JSON值转换为QVariant
    QVariant jsonToQVariant(const nlohmann::json& json) const {
        if (json.is_null()) {
            return QVariant();
        } else if (json.is_boolean()) {
            return QVariant(json.get<bool>());
        } else if (json.is_number_integer()) {
            return QVariant(json.get<int>());
        } else if (json.is_number_float()) {
            return QVariant(json.get<double>());
        } else if (json.is_string()) {
            return QVariant(QString::fromStdString(json.get<std::string>()));
        } else if (json.is_array()) {
            // 可以根据需要扩展数组支持
            return QVariant(QString::fromStdString(json.dump()));
        } else if (json.is_object()) {
            // 可以根据需要扩展对象支持
            return QVariant(QString::fromStdString(json.dump()));
        }
        return QVariant();
    }
    
    // 辅助方法：将QVariant转换为JSON值
    nlohmann::json qVariantToJson(const QVariant& variant) const {
        switch (variant.type()) {
            case QVariant::Bool:
                return variant.toBool();
            case QVariant::Int:
                return variant.toInt();
            case QVariant::Double:
                return variant.toDouble();
            case QVariant::String:
                return variant.toString().toStdString();
            case QVariant::Invalid:
                return nullptr;
            default:
                // 对于其他类型，转换为字符串
                return variant.toString().toStdString();
        }
    }
};