#include "config_mgr.h"
#include <QDebug>
#include <QJsonDocument>
#include <QJsonArray>
#include <QJsonObject>

#include "data_config.h"
#include "vibrationdata.h"
#include "tachometer_data.h"
#include "keyphase_data.h"
#include "singlerelay_data.h"
#include "tmrrelayassociation_data.h"
#include <QCoreApplication>


ConfigMgr *ConfigMgr::instance = nullptr;

ConfigMgr::~ConfigMgr() {
}

void ConfigMgr::Save(QString & file_path) {
    QJsonObject doc_obj;
    int slot = 0;
    QJsonArray card_type;
    for (int i = 0; i < SLOT_NUM; ++i) {
        if (card_type_[i] == kCardNone) {
            continue;
        }
        QJsonObject card_item;
        slot = i + 1;
        card_item["type"] = card_type_[i];
        card_item["slot"] = slot;
        card_type.append(card_item);
        if (card_type_[i] != kCardVibSingle &&
                card_type_[i] != kCardVibTMRPrimary &&
                card_type_[i] != kCardSpeedSingle &&
                card_type_[i] != kCardSpeedTMRPrimary &&
                card_type_[i] != kCardKeyphaseSingle &&
                card_type_[i] != kCardRelaySingle &&
                card_type_[i] != kCardRelayTMRPrimary &&
                card_type_[i] != kCardRelaySingleNOK) {
            continue;
        }
        // process slot
        QJsonObject slot_item;
        if (card_type_[i] != kCardRelaySingle &&
                card_type_[i] != kCardRelayTMRPrimary &&
                card_type_[i] != kCardRelaySingleNOK &&
                card_type_[i] != kCardRelayTMRBackup) {
            for (int cid = 0; cid < CHANNEL_COUNT; ++cid) {
                QJsonObject channel_item;
                if (card_type_[i] == kCardVibSingle ||
                        card_type_[i] == kCardVibTMRPrimary) {
                    std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
                    if (base_ptr == nullptr) {
                        continue;
                    }
                    std::shared_ptr<VibrationData> ptr = std::dynamic_pointer_cast<VibrationData>(base_ptr);
                    channel_item["standby"] = ptr->base_config_[cid].standby;
                    channel_item["active"] = ptr->base_config_[cid].active;
                    channel_item["rack_type"] = 0; // TODO:
                    channel_item["channel_type"] = ptr->base_config_[cid].channel_type;
                    channel_item["transducer_id"] = ptr->base_config_[cid].transducer_id;
                    channel_item["scale_factor"] = ptr->base_config_[cid].scale_factor;
                    channel_item["sampling_rate"] = ptr->base_config_[cid].sampling_rate;
                    channel_item["power"] = ptr->base_config_[cid].power;
                    channel_item["point_name"] = ptr->base_config_[cid].point_name;
                    channel_item["chan_id"] = ptr->base_config_[cid].chan_id;
                    QJsonArray voltage_range;
                    voltage_range.append(ptr->base_config_[cid].normal_voltage_low);
                    voltage_range.append(ptr->base_config_[cid].normal_voltage_high);
                    channel_item["normal_voltage_range"] = voltage_range;
                    QJsonObject setpoint_data;
                    setpoint_data["direct_upper"] = qRound(ptr->alert_danger[cid].direct_upper * 10)/10.0;
                    setpoint_data["direct_enable"] = ptr->alert_danger[cid].direct_enable;
                    setpoint_data["1x_ampl_upper"] = qRound(ptr->alert_danger[cid].x1_ampl_upper * 10)/10.0;
                    setpoint_data["1x_ampl_lower"] = qRound(ptr->alert_danger[cid].x1_ampl_lower * 10)/10.0;
                    setpoint_data["1x_ampl_enable"] = ptr->alert_danger[cid].x1_ampl_enable;
                    setpoint_data["2x_ampl_upper"] = qRound(ptr->alert_danger[cid].x2_ampl_upper * 10)/10.0;
                    setpoint_data["2x_ampl_lower"] = qRound(ptr->alert_danger[cid].x2_ampl_lower * 10)/10.0;
                    setpoint_data["2x_ampl_enable"] = ptr->alert_danger[cid].x2_ampl_enable;
                    setpoint_data["danger_param"] = ptr->alert_danger[cid].danger_param;
                    setpoint_data["danger_upper"] = qRound(ptr->alert_danger[cid].danger_upper * 10)/10.0;
                    setpoint_data["danger_enable"] = ptr->alert_danger[cid].danger_enable;
                    channel_item["setpoint"] = setpoint_data;
                    // variables
                    QJsonObject variables;
                    std::shared_ptr<VariableBase> base_channel_ptr = ptr->GetChannelPtr(cid + 1);
                    if (base_channel_ptr == nullptr) {
                        continue;
                    }
                    if (ptr->base_config_[cid].channel_type == kVibRadial) {
                        std::shared_ptr<RadialVariable> radial_ptr = std::dynamic_pointer_cast<RadialVariable>(base_channel_ptr);
                        if(radial_ptr == nullptr){
                            continue;
                        }
                        // filter
                        QJsonArray filter;
                        QJsonObject low_pass;
                        low_pass["low"] = radial_ptr->filter_[0].low;
                        low_pass["high"] = radial_ptr->filter_[0].high;
                        low_pass["checked"] = radial_ptr->filter_[0].checked;
                        filter.append(low_pass);
                        QJsonObject high_pass;
                        high_pass["low"] = radial_ptr->filter_[1].low;
                        high_pass["high"] = radial_ptr->filter_[1].high;
                        high_pass["checked"] = radial_ptr->filter_[1].checked;
                        filter.append(high_pass);
                        QJsonObject band_pass;
                        band_pass["low"] = radial_ptr->filter_[2].low;
                        band_pass["high"] = radial_ptr->filter_[2].high;
                        band_pass["checked"] = radial_ptr->filter_[2].checked;
                        filter.append(band_pass);
                        variables["filter"] = filter;
                        QJsonObject direct;
                        QJsonObject x1;
                        QJsonObject x2;
                        QJsonObject recorder_out;
                        QJsonObject delay;
                        QJsonArray latching;
                        direct["full_scale_range"] = radial_ptr->direct_.full_scale_range;
                        direct["clamp_value"] = radial_ptr->direct_.clamp_value;
                        direct["custom"] = radial_ptr->direct_.custom;
                        variables["direct"] = direct;
                        x1["checked"] = radial_ptr->x1_.checked;
                        x1["full_scale_range"] = radial_ptr->x1_.full_scale_range;
                        x1["clamp_value"] = radial_ptr->x1_.clamp_value;
                        x1["custom"] = radial_ptr->x1_.custom;
                        x1["phase_lag"] = radial_ptr->x1_.phase_lag;
                        variables["x1"] = x1;
                        x2["checked"] = radial_ptr->x2_.checked;
                        x2["full_scale_range"] = radial_ptr->x2_.full_scale_range;
                        x2["clamp_value"] = radial_ptr->x2_.clamp_value;
                        x2["custom"] = radial_ptr->x2_.custom;
                        x2["phase_lag"] = radial_ptr->x2_.phase_lag;
                        variables["x2"] = x2;
                        recorder_out["recorder_output"] = radial_ptr->recorder_out_.recorder_output;
                        recorder_out["two_ma_clamp"] = radial_ptr->recorder_out_.two_ma_clamp;
                        recorder_out["trip_multiply"] = radial_ptr->recorder_out_.trip_multiply;
                        recorder_out["comparision"] = radial_ptr->recorder_out_.comparision;
                        recorder_out["percentage"] = radial_ptr->recorder_out_.percentage;
                        variables["recorder_out"] = recorder_out;
                        delay["alert"] = radial_ptr->delay_.alert;
                        delay["danger"] = radial_ptr->delay_.danger;
                        delay["active_100ms"] = radial_ptr->delay_.active_100ms;
                        variables["delay"] = delay;
                        latching.append(radial_ptr->alert_latching_);
                        latching.append(radial_ptr->danger_latching_);
                        variables["latching"] = latching;
                    } else {
                        std::shared_ptr<AccVelVariable> av_ptr = std::dynamic_pointer_cast<AccVelVariable>(base_channel_ptr);
                        if(av_ptr == nullptr){
                            continue;
                        }
                        // filter
                        QJsonArray filter;
                        QJsonObject low_pass;
                        low_pass["low"] = av_ptr->filter_[0].low;
                        low_pass["high"] = av_ptr->filter_[0].high;
                        low_pass["checked"] = av_ptr->filter_[0].checked;
                        filter.append(low_pass);
                        QJsonObject high_pass;
                        high_pass["low"] = av_ptr->filter_[1].low;
                        high_pass["high"] = av_ptr->filter_[1].high;
                        high_pass["checked"] = av_ptr->filter_[1].checked;
                        filter.append(high_pass);
                        QJsonObject band_pass;
                        band_pass["low"] = av_ptr->filter_[2].low;
                        band_pass["high"] = av_ptr->filter_[2].high;
                        band_pass["checked"] = av_ptr->filter_[2].checked;
                        filter.append(band_pass);
                        variables["filter"] = filter;
                        QJsonObject direct;
                        QJsonObject x1;
                        QJsonObject x2;
                        QJsonObject recorder_out;
                        QJsonObject delay;
                        QJsonArray latching;
                        direct["full_scale_range"] = av_ptr->direct_.full_scale_range;
                        direct["clamp_value"] = av_ptr->direct_.clamp_value;
                        direct["custom"] = av_ptr->direct_.custom;
                        variables["direct"] = direct;
                        x1["checked"] = av_ptr->x1_.checked;
                        x1["full_scale_range"] = av_ptr->x1_.full_scale_range;
                        x1["clamp_value"] = av_ptr->x1_.clamp_value;
                        x1["custom"] = av_ptr->x1_.custom;
                        x1["phase_lag"] = av_ptr->x1_.phase_lag;
                        variables["x1"] = x1;
                        x2["checked"] = av_ptr->x2_.checked;
                        x2["full_scale_range"] = av_ptr->x2_.full_scale_range;
                        x2["clamp_value"] = av_ptr->x2_.clamp_value;
                        x2["custom"] = av_ptr->x2_.custom;
                        x2["phase_lag"] = av_ptr->x2_.phase_lag;
                        variables["x2"] = x2;
                        QJsonObject rms_integrate;
                        rms_integrate["rms_active"] = av_ptr->rms_active_;
                        rms_integrate["integrate_active"] = av_ptr->integrate_active_;
                        variables["rms_integrate"] = rms_integrate;
                        recorder_out["recorder_output"] = av_ptr->recorder_out_.recorder_output;
                        recorder_out["two_ma_clamp"] = av_ptr->recorder_out_.two_ma_clamp;
                        recorder_out["trip_multiply"] = av_ptr->recorder_out_.trip_multiply;
                        recorder_out["comparision"] = av_ptr->recorder_out_.comparision;
                        recorder_out["percentage"] = av_ptr->recorder_out_.percentage;
                        variables["recorder_out"] = recorder_out;
                        delay["alert"] = av_ptr->delay_.alert;
                        delay["danger"] = av_ptr->delay_.danger;
                        delay["active_100ms"] = av_ptr->delay_.active_100ms;
                        variables["delay"] = delay;
                        latching.append(av_ptr->alert_latching_);
                        latching.append(av_ptr->danger_latching_);
                        latching.append(av_ptr->timed_ok_);
                        variables["latching"] = latching;
                    }
                    channel_item["variable"] = variables;
                } else if (card_type_[i] == kCardSpeedSingle || card_type_[i] == kCardSpeedTMRPrimary) {
                    std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
                    if (base_ptr == nullptr) {
                        continue;
                    }
                    std::shared_ptr<TachometerData> ptr = std::dynamic_pointer_cast<TachometerData>(base_ptr);
                    QJsonArray voltage_range_array;
                    voltage_range_array.append(ptr->variables_[cid].normal_voltage_low);
                    voltage_range_array.append(ptr->variables_[cid].normal_voltage_high);
                    QJsonObject setpoint_data;
                    setpoint_data["speed_upper"] = ptr->alert_danger[cid].speed_upper;
                    setpoint_data["speed_lower"] = ptr->alert_danger[cid].speed_lower;
                    setpoint_data["speed_upper_enable"] = ptr->alert_danger[cid].speed_upper_enable;
                    setpoint_data["speed_lower_enable"] = ptr->alert_danger[cid].speed_lower_enable;
                    setpoint_data["danger_speed_upper"] = ptr->alert_danger[cid].danger_speed_upper;
                    channel_item["setpoint"] = setpoint_data;
                    channel_item.insert("active", ptr->variables_[cid].active);
                    channel_item.insert("normal_voltage_range", voltage_range_array);
                    channel_item.insert("threshold", ptr->variables_[cid].threshold);
                    channel_item.insert("hysteresis", ptr->variables_[cid].hysteresis);
                    channel_item.insert("events_per_revolution", ptr->variables_[cid].events_per_revolution);
                    channel_item.insert("record_output", ptr->variables_[cid].record_output);
                    channel_item.insert("two_ma_clamp", ptr->variables_[cid].two_ma_clamp);
                    channel_item.insert("alert_latching", ptr->variables_[cid].alert_latching);
                    channel_item.insert("overspeed_latching", ptr->variables_[cid].overspeed_latching);
                    channel_item.insert("normal_latching", ptr->variables_[cid].normal_latching);
                    channel_item.insert("speed_peak", ptr->variables_[cid].speed_peek);
                    channel_item.insert("default_speed", ptr->variables_[cid].default_speed);
                    channel_item.insert("automatic_threshold",ptr->variables_[cid].automatic_threshold);

                } else if (card_type_[i] == kCardKeyphaseSingle) {
                    std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
                    if (base_ptr == nullptr) {
                        continue;
                    }
                    std::shared_ptr<KeyphaseData> ptr = std::dynamic_pointer_cast<KeyphaseData>(base_ptr);
                    QJsonArray voltage_range_array;
                    voltage_range_array.append(ptr->variables_[cid].normal_voltage_low);
                    voltage_range_array.append(ptr->variables_[cid].normal_voltage_high);
                    channel_item.insert("active", ptr->variables_[cid].active);
                    channel_item.insert("normal_voltage_range", voltage_range_array);
                    channel_item.insert("threshold", ptr->variables_[cid].threshold);
                    channel_item.insert("hysteresis", ptr->variables_[cid].hysteresis);
                    channel_item.insert("events_per_revolution", ptr->variables_[cid].events_per_revolution);
                    channel_item.insert("automatic_threshold",ptr->variables_[cid].automatic_threshold);
                }
                slot_item[QString::number(cid + 1)] = channel_item;
            }
            slot_item["version"] = 1;
        }else{
            for(int ch = 0;ch < RELAY_COUNT;++ch){
                QJsonObject channel_item;
                if(card_type_[i] == kCardRelaySingleNOK){
                    std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
                    if (base_ptr == nullptr) {
                        continue;
                    }
                    std::shared_ptr<SingleRelayDataNOK> ptr = std::dynamic_pointer_cast<SingleRelayDataNOK>(base_ptr);
                    if(ptr->single_relay_nok[ch].logic_expression != ""){
                        qDebug() << "ch" << ch << ptr->single_relay_nok[ch].logic_expression;
                        channel_item.insert("logic_expression", ptr->single_relay_nok[ch].logic_expression);
                    }

                }else if(card_type_[i] == kCardRelaySingle){
                    std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
                    if (base_ptr == nullptr) {
                        continue;
                    }
                    std::shared_ptr<TmrrelayassociationData> ptr = std::dynamic_pointer_cast<TmrrelayassociationData>(base_ptr);
                    if(ptr->tmr_relay[ch].logic_expression != "")
                        channel_item.insert("logic_expression", ptr->tmr_relay[ch].logic_expression);
                }else if(card_type_[i] == kCardRelayTMRPrimary){
                    std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
                    if (base_ptr == nullptr) {
                        continue;
                    }
                    std::shared_ptr<TmrrelayassociationData> ptr = std::dynamic_pointer_cast<TmrrelayassociationData>(base_ptr);
                    slot_item["sgcc_enable"] = ptr->sgcc_enable;
                    if(ptr->tmr_relay[ch].logic_expression != ""){
                        channel_item.insert("logic_expression", ptr->tmr_relay[ch].logic_expression);
                    }
                }
                if(!channel_item.isEmpty() ){
                    slot_item[QString::number(ch + 1)] = channel_item;
                }
            }
            slot_item["version"] = 1;
        }
        doc_obj[QString::number(slot)] = slot_item;
    }
    doc_obj["card_type"] = card_type;
    // TODO: show success message box
    QJsonDocument jsonDoc;
    jsonDoc.setObject(doc_obj);
    QFile file(file_path);
    file.open(QIODevice::WriteOnly);
    file.write(jsonDoc.toJson());
    file.close();
}

void ConfigMgr::Load(QString filename) {
    QFile file(filename);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        // TODO: show message box
        qDebug() << "Cannot open file for reading:" << filename;
        return;
    }
    QString content = file.readAll();
    file.close();
    QByteArray jsonData = content.toUtf8();
    QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonData);
    if (jsonDoc.isNull()) {
        // TODO: show message box
        qDebug() << "Cannot parse JSON document";
        return;
    }
    if (!jsonDoc.isObject() && !jsonDoc.isArray()) {
        // TODO: show message box
        qDebug() << "JSON document is not an object or an array";
        return;
    }
    filename_ = filename;
    QJsonObject json_obj = jsonDoc.object();
    // parse card_type
    QJsonArray card_type = json_obj["card_type"].toArray();
    int slot = 0;
    QJsonObject temp_obj;
    for (int i = 0; i < card_type.size(); ++i) {
        temp_obj = card_type[i].toObject();
        slot = temp_obj["slot"].toInt();
        card_type_[slot - 1] = static_cast<CardType>(temp_obj["type"].toInt());
    }
    // parse each slot
    QJsonObject channel;
    for (int i = 0; i < SLOT_NUM; ++i) {
        if (card_type_[i] == kCardNone) {
            continue;
        }
        slot = i + 1;
        if (json_obj[QString::number(slot)].isNull() && card_type_[i] != kCardRelayTMRBackup) {
            continue;
        }
        temp_obj = json_obj[QString::number(slot)].toObject();
        if (card_type_[i] == kCardVibSingle) {
            std::shared_ptr<VibrationData> vib_data = std::make_shared<VibrationData>();
            vib_data->version_ = temp_obj["version"].toInt();
            vib_data->card_type_ = static_cast<CardType>(card_type_[i]);
            vib_data->slot_ = slot;
            for (int j = 0; j < CHANNEL_COUNT; ++j) {
                std::shared_ptr<VariableBase> base_channel_ptr = vib_data->GetChannelPtr(j + 1);
                channel = temp_obj[QString::number(j + 1)].toObject();
                if(channel.isEmpty())
                    continue;
                // base info
                vib_data->base_config_[j].standby = channel["standby"].toBool();
                vib_data->base_config_[j].active = channel["active"].toBool();
                vib_data->base_config_[j].rack_type = channel["rack_type"].toInt();
//                vib_data->base_config_[j].tmr_group = channel["tmr_group"].toString();
                vib_data->base_config_[j].channel_type = channel["channel_type"].toInt();
                vib_data->base_config_[j].transducer_id = channel["transducer_id"].toInt();
                vib_data->base_config_[j].scale_factor = channel["scale_factor"].toDouble();
                vib_data->base_config_[j].sampling_rate = channel["sampling_rate"].toInt();
                QJsonArray voltage_range_array = channel["normal_voltage_range"].toArray();
                vib_data->base_config_[j].normal_voltage_low = voltage_range_array[0].toDouble();
                vib_data->base_config_[j].normal_voltage_high = voltage_range_array[1].toDouble();
                vib_data->base_config_[j].power = channel["power"].toBool();
                vib_data->base_config_[j].point_name = channel["point_name"].toString();
                vib_data->base_config_[j].chan_id = channel["chan_id"].toString();
                //setpoint
                QJsonObject setpoint_data = channel["setpoint"].toObject();
                vib_data->alert_danger[j].direct_upper = setpoint_data["direct_upper"].toDouble();
                vib_data->alert_danger[j].direct_enable = setpoint_data["direct_enable"].toBool();
                vib_data->alert_danger[j].x1_ampl_upper = setpoint_data["1x_ampl_upper"].toDouble();
                vib_data->alert_danger[j].x1_ampl_lower = setpoint_data["1x_ampl_lower"].toDouble();
                vib_data->alert_danger[j].x1_ampl_enable = setpoint_data["1x_ampl_enable"].toBool();
                vib_data->alert_danger[j].x2_ampl_upper = setpoint_data["2x_ampl_upper"].toDouble();
                vib_data->alert_danger[j].x2_ampl_lower = setpoint_data["2x_ampl_lower"].toDouble();
                vib_data->alert_danger[j].x2_ampl_enable = setpoint_data["2x_ampl_enable"].toBool();
                vib_data->alert_danger[j].danger_param = setpoint_data["danger_param"].toInt();
                vib_data->alert_danger[j].danger_upper = setpoint_data["danger_upper"].toDouble();
                vib_data->alert_danger[j].danger_enable = setpoint_data["danger_enable"].toBool();
                // variables
                QJsonObject tmp_variable = channel["variable"].toObject();
                switch (vib_data->base_config_[j].channel_type) {
                    case kVibRadial: {
                        std::shared_ptr<RadialVariable> variable = std::make_shared<RadialVariable>();
                        // filter
                        QJsonArray filter_array = tmp_variable["filter"].toArray();
                        for (int k = 0; k < filter_array.size(); k++) {
                            QJsonObject filter_ele = filter_array[k].toObject();
                            variable->filter_[k].low = filter_ele["low"].toInt();
                            variable->filter_[k].high = filter_ele["high"].toInt();
                            variable->filter_[k].checked = filter_ele["checked"].toBool();
                        }
                        variable->id_ = j + 1;
                        QJsonObject direct = tmp_variable["direct"].toObject();
                        variable->direct_.full_scale_range = direct["full_scale_range"].toInt();
                        variable->direct_.clamp_value = direct["clamp_value"].toDouble();
                        variable->direct_.custom = direct["custom"].toDouble();
                        QJsonObject x1 = tmp_variable["x1"].toObject();
                        variable->x1_.checked = x1["checked"].toBool();
                        variable->x1_.full_scale_range = x1["full_scale_range"].toInt();
                        variable->x1_.clamp_value = x1["clamp_value"].toDouble();
                        variable->x1_.custom = x1["custom"].toDouble();
                        variable->x1_.phase_lag = x1["phase_lag"].toInt();
                        QJsonObject x2 = tmp_variable["x2"].toObject();
                        variable->x2_.checked = x2["checked"].toBool();
                        variable->x2_.full_scale_range = x2["full_scale_range"].toInt();
                        variable->x2_.clamp_value = x2["clamp_value"].toDouble();
                        variable->x2_.custom = x2["custom"].toDouble();
                        variable->x2_.phase_lag = x2["phase_lag"].toInt();
                        QJsonObject recorder_out = tmp_variable["recorder_out"].toObject();
                        variable->recorder_out_.recorder_output = recorder_out["recorder_output"].toInt();
                        variable->recorder_out_.two_ma_clamp = recorder_out["two_ma_clamp"].toBool();
                        variable->recorder_out_.trip_multiply = recorder_out["trip_multiply"].toDouble();
                        variable->recorder_out_.comparision = recorder_out["comparision"].toInt();
                        variable->recorder_out_.percentage = recorder_out["percentage"].toInt();
                        QJsonObject delay = tmp_variable["delay"].toObject();
                        variable->delay_.alert = delay["alert"].toInt();
                        variable->delay_.danger = delay["danger"].toDouble();
                        variable->delay_.active_100ms = delay["active_100ms"].toBool();
                        QJsonObject latching = tmp_variable["latching"].toObject();
                        variable->alert_latching_ = latching["alert"].toBool();
                        variable->danger_latching_ = latching["danger"].toBool();
                        vib_data->variables_.push_back(variable);
                        break;
                    }
                    case kVibVelocity:
                    case kVibAcc: {
                        std::shared_ptr<AccVelVariable> variable = std::make_shared<AccVelVariable>();
                        // filter
                        QJsonArray filter_array = tmp_variable["filter"].toArray();
                        for (int k = 0; k < filter_array.size(); k++) {
                            QJsonObject filter_ele = filter_array[k].toObject();
                            variable->filter_[k].low = filter_ele["low"].toInt();
                            variable->filter_[k].high = filter_ele["high"].toInt();
                            variable->filter_[k].checked = filter_ele["checked"].toBool();
                        }
                        variable->id_ = j + 1;
                        QJsonObject direct = tmp_variable["direct"].toObject();
                        variable->direct_.full_scale_range = direct["full_scale_range"].toInt();
                        variable->direct_.clamp_value = direct["clamp_value"].toDouble();
                        variable->direct_.custom = direct["custom"].toDouble();
                        QJsonObject x1 = tmp_variable["x1"].toObject();
                        variable->x1_.checked = x1["checked"].toBool();
                        variable->x1_.full_scale_range = x1["full_scale_range"].toInt();
                        variable->x1_.clamp_value = x1["clamp_value"].toDouble();
                        variable->x1_.custom = x1["custom"].toDouble();
                        variable->x1_.phase_lag = x1["phase_lag"].toInt();
                        QJsonObject x2 = tmp_variable["x2"].toObject();
                        variable->x2_.checked = x2["checked"].toBool();
                        variable->x2_.full_scale_range = x2["full_scale_range"].toInt();
                        variable->x2_.clamp_value = x2["clamp_value"].toDouble();
                        variable->x2_.custom = x2["custom"].toDouble();
                        variable->x2_.phase_lag = x2["phase_lag"].toInt();
                        QJsonObject rms_integrate = tmp_variable["rms_integrate"].toObject();
                        variable->rms_active_ = rms_integrate["rms_active"].toBool();
                        variable->integrate_active_ = rms_integrate["integrate_active"].toBool();
                        QJsonObject recorder_out = tmp_variable["recorder_out"].toObject();
                        variable->recorder_out_.recorder_output = recorder_out["recorder_output"].toInt();
                        variable->recorder_out_.two_ma_clamp = recorder_out["two_ma_clamp"].toBool();
                        variable->recorder_out_.trip_multiply = recorder_out["trip_multiply"].toDouble();
                        variable->recorder_out_.comparision = recorder_out["comparision"].toInt();
                        variable->recorder_out_.percentage = recorder_out["percentage"].toInt();
                        QJsonObject delay = tmp_variable["delay"].toObject();
                        variable->delay_.alert = delay["alert"].toInt();
                        variable->delay_.danger = delay["danger"].toDouble();
                        variable->delay_.active_100ms = delay["active_100ms"].toBool();
                        QJsonObject latching = tmp_variable["latching"].toObject();
                        variable->alert_latching_ = latching["alert"].toBool();
                        variable->danger_latching_ = latching["danger"].toBool();
                        variable->timed_ok_ = latching["timed_ok"].toBool();
                        vib_data->variables_.push_back(variable);
                        break;
                    }
                }
            }
            cards_.push_back(vib_data);
        } else if (card_type_[i] == kCardSpeedSingle ||
                   card_type_[i] == kCardSpeedTMRPrimary) {
            std::shared_ptr<TachometerData> speed_data = std::make_shared<TachometerData>();
            speed_data->slot_ = slot;
            speed_data->card_type_ = static_cast<CardType>(card_type_[i]);
            speed_data->version_ = temp_obj["version"].toInt();
            for (int j = 0; j < CHANNEL_COUNT; ++j) {
                channel = temp_obj[QString::number(j + 1)].toObject();
                speed_data->variables_[j].active = channel["active"].toBool();
                QJsonArray voltage_range_array = channel["normal_voltage_range"].toArray();
                speed_data->variables_[j].normal_voltage_high = voltage_range_array[1].toDouble();
                speed_data->variables_[j].normal_voltage_low = voltage_range_array[0].toDouble();
                speed_data->variables_[j].threshold = channel["threshold"].toDouble();
                speed_data->variables_[j].hysteresis = channel["hysteresis"].toDouble();
                speed_data->variables_[j].events_per_revolution = channel["events_per_revolution"].toInt();
                speed_data->variables_[j].record_output = channel["record_output"].toInt();
                speed_data->variables_[j].two_ma_clamp = channel["two_ma_clamp"].toBool();
                speed_data->variables_[j].alert_latching = channel["alert_latching"].toBool();
                speed_data->variables_[j].overspeed_latching = channel["overspeed_latching"].toBool();
                speed_data->variables_[j].normal_latching = channel["normal_latching"].toBool();
                speed_data->variables_[j].speed_peek = channel["speed_peak"].toInt();
                speed_data->variables_[j].default_speed = channel["default_speed"].toInt();
                speed_data->variables_[j].automatic_threshold = channel["automatic_threshold"].toBool();


                QJsonObject setpoint_data = channel["setpoint"].toObject();
                speed_data->alert_danger[j].speed_upper = setpoint_data["speed_upper"].toDouble();
                speed_data->alert_danger[j].speed_lower = setpoint_data["speed_lower"].toDouble();
                speed_data->alert_danger[j].speed_upper_enable = setpoint_data["speed_upper_enable"].toBool();
                speed_data->alert_danger[j].speed_lower_enable = setpoint_data["speed_lower_enable"].toBool();
                speed_data->alert_danger[j].danger_speed_upper = setpoint_data["danger_speed_upper"].toDouble();
            }
            cards_.push_back(speed_data);
        } else if (card_type_[i] == kCardKeyphaseSingle) {
            std::shared_ptr<KeyphaseData> keyphase_data = std::make_shared<KeyphaseData>();
            keyphase_data->slot_ = slot;
            keyphase_data->card_type_ = static_cast<CardType>(card_type_[i]);
            keyphase_data->version_ = temp_obj["version"].toInt();
            for (int j = 0; j < CHANNEL_COUNT; ++j) {
                channel = temp_obj[QString::number(j + 1)].toObject();
                keyphase_data->variables_[j].active = channel["active"].toBool();
                QJsonArray voltage_range_array = channel["normal_voltage_range"].toArray();
                keyphase_data->variables_[j].normal_voltage_high = voltage_range_array[1].toDouble();
                keyphase_data->variables_[j].normal_voltage_low = voltage_range_array[0].toDouble();
                keyphase_data->variables_[j].threshold = channel["threshold"].toDouble();
                keyphase_data->variables_[j].hysteresis = channel["hysteresis"].toDouble();
                keyphase_data->variables_[j].events_per_revolution = channel["events_per_revolution"].toInt();
                keyphase_data->variables_[j].automatic_threshold = channel["automatic_threshold"].toBool();
            }
            cards_.push_back(keyphase_data);
        }else if (card_type_[i] == kCardRelaySingleNOK ){
            std::shared_ptr<SingleRelayDataNOK> singlerelay_data = std::make_shared<SingleRelayDataNOK>();
            singlerelay_data->slot_ = slot;
            singlerelay_data->card_type_ = static_cast<CardType>(card_type_[i]);
            singlerelay_data->version_ = temp_obj["version"].toInt();
            for (int j = 0; j < RELAY_COUNT; ++j) {
                 channel = temp_obj[QString::number(j + 1)].toObject();
                 singlerelay_data->single_relay_nok[j].logic_expression = channel["logic_expression"].toString();
            }
            cards_.push_back(singlerelay_data);
        }else if(card_type_[i] == kCardRelaySingle){
            std::shared_ptr<TmrrelayassociationData> relay_data = std::make_shared<TmrrelayassociationData>();
            relay_data->slot_ = slot;
            relay_data->card_type_ = static_cast<CardType>(card_type_[i]);
            relay_data->version_ = temp_obj["version"].toInt();
            for (int j = 0; j < RELAY_COUNT; ++j) {
                 channel = temp_obj[QString::number(j + 1)].toObject();
                 relay_data->tmr_relay[j].logic_expression = channel["logic_expression"].toString();
            }
            cards_.push_back(relay_data);
        }else if(card_type_[i] == kCardRelayTMRPrimary){
            std::shared_ptr<TmrrelayassociationData> relay_data = std::make_shared<TmrrelayassociationData>();
            relay_data->slot_ = slot;
            relay_data->card_type_ = static_cast<CardType>(card_type_[i]);
            relay_data->version_ = temp_obj["version"].toInt();
            relay_data->sgcc_enable = temp_obj["sgcc_enable"].toBool();
            for (int j = 0; j < RELAY_COUNT; ++j) {
                 channel = temp_obj[QString::number(j + 1)].toObject();
                 relay_data->tmr_relay[j].logic_expression = channel["logic_expression"].toString();

            }
            cards_.push_back(relay_data);
        }else if(card_type_[i] == kCardRelayTMRBackup){
            std::shared_ptr<TmrrelayassociationData> relay_data = std::make_shared<TmrrelayassociationData>();
            relay_data->slot_ = slot;
            relay_data->card_type_ = static_cast<CardType>(card_type_[i]);
            cards_.push_back(relay_data);
        }
    }
}

std::shared_ptr<CardBase> ConfigMgr::GetSlotPtr(int slot) {
    for (auto &item : cards_) {
        if (item->slot_ == slot) {
            return item;
        }
    }
    return nullptr;
}

void ConfigMgr::AddCard(std::shared_ptr<CardBase> ptr) {
    cards_.push_back(ptr);
}
void ConfigMgr::RemoveCard(std::shared_ptr<CardBase> ptr) {
    cards_.erase(remove(cards_.begin(), cards_.end(), ptr));
}