#include <QtDebug>
#include <QDateTime>

#include "experimentsettingform.h"
#include "ui_experimentsettingform.h"
#include "protocol.h"
#include "dataparser.h"
#include "serialport.h"
#include "global.h"
#include "filemanager.h"
#include "logger.h"

QString extractObjectName(const QString &fullObjectName) {
    return fullObjectName.mid(4);    // 去掉前 4 个字符（"ui->"）
}

#define SET_OBJECT_NAME(WIDGET) \
    WIDGET->setObjectName(extractObjectName(#WIDGET))

ExperimentSettingForm::ExperimentSettingForm(QWidget *parent) : QWidget(parent),
                                                                ui(new Ui::ExperimentSettingForm) {
    ui->setupUi(this);

    ui->sampleNameLineEdit->setText("new");
    ui->sampleWeightLineEdit->setText("0");
    ui->userLineEdit->setText("user");

    uiReset();

    ui->checkBox_phase_1->setTristate(false);
    ui->checkBox_phase_2->setTristate(false);
    ui->checkBox_phase_3->setTristate(false);
    ui->checkBox_phase_4->setTristate(false);
    ui->checkBox_phase_5->setTristate(false);
    ui->checkBox_phase_6->setTristate(false);

    connect(ui->checkBox_phase_2, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase2StateChanged);
    connect(ui->checkBox_phase_3, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase3StateChanged);
    connect(ui->checkBox_phase_4, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase4StateChanged);
    connect(ui->checkBox_phase_5, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase5StateChanged);
    connect(ui->checkBox_phase_6, &QCheckBox::clicked,
            this, &ExperimentSettingForm::slotPhase6StateChanged);

    //    connect(ui->pushButton_connect_to_device,&QPushButton::clicked,
    //            this,&ExperimentSettingForm::slotConnectToDevice);

    connect(ui->pushButton_cancel, &QPushButton::clicked,
            this, &ExperimentSettingForm::slotCancel);
}

ExperimentSettingForm::~ExperimentSettingForm() {
    delete ui;
}

void ExperimentSettingForm::uiReset() {
    // init data and status.

    // default value
    ui->phase_1_cutoff_temp->setText("0");
    ui->phase_2_cutoff_temp->setText("0");
    ui->phase_3_cutoff_temp->setText("0");
    ui->phase_4_cutoff_temp->setText("0");
    ui->phase_5_cutoff_temp->setText("0");
    ui->phase_6_cutoff_temp->setText("0");

    ui->phase_1_scan_rate->setText("0");
    ui->phase_2_scan_rate->setText("0");
    ui->phase_3_scan_rate->setText("0");
    ui->phase_4_scan_rate->setText("0");
    ui->phase_5_scan_rate->setText("0");
    ui->phase_6_scan_rate->setText("0");

    ui->phase_1_constant_temp->setText("0");
    ui->phase_2_constant_temp->setText("0");
    ui->phase_3_constant_temp->setText("0");
    ui->phase_4_constant_temp->setText("0");
    ui->phase_5_constant_temp->setText("0");
    ui->phase_6_constant_temp->setText("0");

    ui->comboBox_phase_1_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_2_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_3_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_4_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_5_atmosphere->setCurrentIndex(0);
    ui->comboBox_phase_6_atmosphere->setCurrentIndex(0);

    // default enable
    ui->checkBox_phase_1->setChecked(true);
    ui->checkBox_phase_1->setEnabled(false);

    ui->phase_2_cutoff_temp->setEnabled(false);
    ui->phase_3_cutoff_temp->setEnabled(false);
    ui->phase_4_cutoff_temp->setEnabled(false);
    ui->phase_5_cutoff_temp->setEnabled(false);
    ui->phase_6_cutoff_temp->setEnabled(false);

    ui->phase_2_scan_rate->setEnabled(false);
    ui->phase_3_scan_rate->setEnabled(false);
    ui->phase_4_scan_rate->setEnabled(false);
    ui->phase_5_scan_rate->setEnabled(false);
    ui->phase_6_scan_rate->setEnabled(false);

    ui->phase_2_constant_temp->setEnabled(false);
    ui->phase_3_constant_temp->setEnabled(false);
    ui->phase_4_constant_temp->setEnabled(false);
    ui->phase_5_constant_temp->setEnabled(false);
    ui->phase_6_constant_temp->setEnabled(false);

    ui->comboBox_phase_2_atmosphere->setEnabled(false);
    ui->comboBox_phase_3_atmosphere->setEnabled(false);
    ui->comboBox_phase_4_atmosphere->setEnabled(false);
    ui->comboBox_phase_5_atmosphere->setEnabled(false);
    ui->comboBox_phase_6_atmosphere->setEnabled(false);

    ui->radioButton_OIT_not->setChecked(true);

    ui->checkBox_phase_2->setTristate(false);
    ui->checkBox_phase_3->setTristate(false);
    ui->checkBox_phase_4->setTristate(false);
    ui->checkBox_phase_5->setTristate(false);
    ui->checkBox_phase_6->setTristate(false);

    // set objectName
    SET_OBJECT_NAME(ui->checkBox_phase_1);
    SET_OBJECT_NAME(ui->checkBox_phase_2);
    SET_OBJECT_NAME(ui->checkBox_phase_3);
    SET_OBJECT_NAME(ui->checkBox_phase_4);
    SET_OBJECT_NAME(ui->checkBox_phase_5);
    SET_OBJECT_NAME(ui->checkBox_phase_6);

    SET_OBJECT_NAME(ui->phase_1_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_2_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_3_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_4_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_5_cutoff_temp);
    SET_OBJECT_NAME(ui->phase_6_cutoff_temp);

    SET_OBJECT_NAME(ui->phase_1_scan_rate);
    SET_OBJECT_NAME(ui->phase_2_scan_rate);
    SET_OBJECT_NAME(ui->phase_3_scan_rate);
    SET_OBJECT_NAME(ui->phase_4_scan_rate);
    SET_OBJECT_NAME(ui->phase_5_scan_rate);
    SET_OBJECT_NAME(ui->phase_6_scan_rate);

    SET_OBJECT_NAME(ui->phase_1_constant_temp);
    SET_OBJECT_NAME(ui->phase_2_constant_temp);
    SET_OBJECT_NAME(ui->phase_3_constant_temp);
    SET_OBJECT_NAME(ui->phase_4_constant_temp);
    SET_OBJECT_NAME(ui->phase_5_constant_temp);
    SET_OBJECT_NAME(ui->phase_6_constant_temp);

    SET_OBJECT_NAME(ui->comboBox_phase_1_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_2_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_3_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_4_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_5_atmosphere);
    SET_OBJECT_NAME(ui->comboBox_phase_6_atmosphere);

    SET_OBJECT_NAME(ui->radioButton_OIT_not);
    SET_OBJECT_NAME(ui->comboBox_initial_atmosphere);
}

void ExperimentSettingForm::uiSetPhaseEnable(const int index) {
    switch (index) {
        case 1:
            ui->checkBox_phase_1->setTristate(true);
            ui->phase_1_cutoff_temp->setEnabled(true);
            ui->phase_1_scan_rate->setEnabled(true);
            ui->phase_1_constant_temp->setEnabled(true);
            ui->comboBox_phase_1_atmosphere->setEnabled(true);
            break;
        case 2:
            ui->checkBox_phase_2->setTristate(true);
            ui->phase_2_cutoff_temp->setEnabled(true);
            ui->phase_2_scan_rate->setEnabled(true);
            ui->phase_3_constant_temp->setEnabled(true);
            ui->comboBox_phase_1_atmosphere->setEnabled(true);
            break;
        case 3:
            ui->checkBox_phase_1->setTristate(true);
            ui->phase_1_cutoff_temp->setEnabled(true);
            ui->phase_1_scan_rate->setEnabled(true);
            ui->phase_1_constant_temp->setEnabled(true);
            ui->comboBox_phase_1_atmosphere->setEnabled(true);
            break;
        case 4:
            ui->checkBox_phase_1->setTristate(true);
            ui->phase_1_cutoff_temp->setEnabled(true);
            ui->phase_1_scan_rate->setEnabled(true);
            ui->phase_1_constant_temp->setEnabled(true);
            ui->comboBox_phase_1_atmosphere->setEnabled(true);
            break;
        case 5:
            ui->checkBox_phase_1->setTristate(true);
            ui->phase_1_cutoff_temp->setEnabled(true);
            ui->phase_1_scan_rate->setEnabled(true);
            ui->phase_1_constant_temp->setEnabled(true);
            ui->comboBox_phase_1_atmosphere->setEnabled(true);
            break;
        case 6:
            ui->checkBox_phase_1->setTristate(true);
            ui->phase_1_cutoff_temp->setEnabled(true);
            ui->phase_1_scan_rate->setEnabled(true);
            ui->phase_1_constant_temp->setEnabled(true);
            ui->comboBox_phase_1_atmosphere->setEnabled(true);
            break;
        default:
            break;
    }
}

GasType ExperimentSettingForm::conver2GasType(const int index) {
    switch (index) {
        case 0:
            return GasType::NC;
            break;    // 假设 GAS_AIR 是 gas_type 的枚举值
        case 1:
            return GasType::N2;
            break;
        case 2:
            return GasType::O2;
            break;
        default:
            return GasType::NC;
            break;    // 处理未知情况
    }
    return GasType::NC;
}

bool ExperimentSettingForm::phaseCufoffTempAndTempFlowCheck(const int   phaseIndex,
                                                            const float prePhaseCufoffTemp,
                                                            const float currentPhaseCufoffTemp,
                                                            const float tempFlow) {
    if (tempFlow < 0) {
        phaseScanRateErrorMesgBox(phaseIndex);
        return false;
    }

    if (prePhaseCufoffTemp != currentPhaseCufoffTemp
        && tempFlow == 0) {
        phaseScanRateErrorMesgBox(phaseIndex);
        return false;
    }

    return true;
}

void ExperimentSettingForm::slotPhase2StateChanged(int state) {
    qDebug() << "slotPhase2StateChanged:" << state;

    if (state == Qt::PartiallyChecked) {
        ui->phase_2_cutoff_temp->setEnabled(true);
        ui->phase_2_scan_rate->setEnabled(true);
        ui->phase_2_constant_temp->setEnabled(true);
        ui->comboBox_phase_2_atmosphere->setEnabled(true);
    } else {
        // unchecked
        if (ui->checkBox_phase_3->isChecked()) {
            ui->checkBox_phase_2->setChecked(true);
        } else {
            ui->phase_2_cutoff_temp->setEnabled(false);
            ui->phase_2_scan_rate->setEnabled(false);
            ui->phase_2_constant_temp->setEnabled(false);
            ui->comboBox_phase_2_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotPhase3StateChanged(int state) {
    if (state == Qt::PartiallyChecked) {
        if (ui->checkBox_phase_2->isChecked()) {
            ui->phase_3_cutoff_temp->setEnabled(true);
            ui->phase_3_scan_rate->setEnabled(true);
            ui->phase_3_constant_temp->setEnabled(true);
            ui->comboBox_phase_3_atmosphere->setEnabled(true);
        } else {
            ui->checkBox_phase_3->setChecked(false);
        }
    } else {
        if (ui->checkBox_phase_4->isChecked()) {
            ui->checkBox_phase_3->setChecked(true);
        } else {
            ui->phase_3_cutoff_temp->setEnabled(false);
            ui->phase_3_scan_rate->setEnabled(false);
            ui->phase_3_constant_temp->setEnabled(false);
            ui->comboBox_phase_3_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotPhase4StateChanged(int state) {
    if (state == Qt::PartiallyChecked) {
        if (ui->checkBox_phase_3->isChecked()) {
            ui->phase_4_cutoff_temp->setEnabled(true);
            ui->phase_4_scan_rate->setEnabled(true);
            ui->phase_4_constant_temp->setEnabled(true);
            ui->comboBox_phase_4_atmosphere->setEnabled(true);
        } else {
            ui->checkBox_phase_4->setChecked(false);
        }
    } else {
        if (ui->checkBox_phase_5->isChecked()) {
            ui->checkBox_phase_4->setChecked(true);
        } else {
            ui->phase_4_cutoff_temp->setEnabled(false);
            ui->phase_4_scan_rate->setEnabled(false);
            ui->phase_4_constant_temp->setEnabled(false);
            ui->comboBox_phase_4_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotPhase5StateChanged(int state) {
    if (state == Qt::PartiallyChecked) {
        if (ui->checkBox_phase_4->isChecked()) {
            ui->phase_5_cutoff_temp->setEnabled(true);
            ui->phase_5_scan_rate->setEnabled(true);
            ui->phase_5_constant_temp->setEnabled(true);
            ui->comboBox_phase_5_atmosphere->setEnabled(true);
        } else {
            ui->checkBox_phase_5->setChecked(false);
        }
    } else {
        if (ui->checkBox_phase_6->isChecked()) {
            ui->checkBox_phase_5->setChecked(true);
        } else {
            ui->phase_5_cutoff_temp->setEnabled(false);
            ui->phase_5_scan_rate->setEnabled(false);
            ui->phase_5_constant_temp->setEnabled(false);
            ui->comboBox_phase_5_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotPhase6StateChanged(int state) {
    qDebug() << "slotPhase2StateChanged:" << state;

    if (state == Qt::PartiallyChecked) {
        if (ui->checkBox_phase_5->isChecked()) {
            ui->phase_6_cutoff_temp->setEnabled(true);
            ui->phase_6_scan_rate->setEnabled(true);
            ui->phase_6_constant_temp->setEnabled(true);
            ui->comboBox_phase_6_atmosphere->setEnabled(true);
        } else {
            ui->checkBox_phase_6->setChecked(false);
        }
    } else {
        ui->phase_6_cutoff_temp->setEnabled(false);
        ui->phase_6_scan_rate->setEnabled(false);
        ui->phase_6_constant_temp->setEnabled(false);
        ui->comboBox_phase_6_atmosphere->setEnabled(false);
    }
}

void ExperimentSettingForm::on_pushButton_deliverData_clicked() {
    float phase1CutoffTemp = 0.0;
    float phase2CutoffTemp = 0.0;
    float phase3CutoffTemp = 0.0;
    float phase4CutoffTemp = 0.0;
    float phase5CutoffTemp = 0.0;
    float phase6CutoffTemp = 0.0;

    QVector<Phase> phaseVtr;
    {
        Phase phase;
        phase.onoff                  = ui->checkBox_phase_1->checkState() ? 1 : 0;
        phase.cutoff_temp            = ui->phase_1_cutoff_temp->text().toFloat();
        phase.temp_flow              = ui->phase_1_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_1_constant_temp->text().toInt();

        phase.gas = conver2GasType(ui->comboBox_phase_1_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        phase1CutoffTemp = phase.cutoff_temp;
        //
        if (phase.temp_flow <= 0) {
            phaseScanRateErrorMesgBox(1);
            return;
        }
    }

    {
        Phase phase;
        phase.onoff                  = ui->checkBox_phase_2->checkState() ? 1 : 0;
        phase.cutoff_temp            = ui->phase_2_cutoff_temp->text().toFloat();
        phase.temp_flow              = ui->phase_2_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_2_constant_temp->text().toInt();
        phase.gas                    = conver2GasType(ui->comboBox_phase_2_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if (phase.onoff) {
            logde << "phase 2 enable.";
            phase2CutoffTemp = phase.cutoff_temp;
            if (phase2CutoffTemp < phase1CutoffTemp) {
                phaseCufoffTempErrorMesgBox(2);
                return;
            }

            //
#if 0
            if(phase.temp_flow < 0){
                phaseScanRateErrorMesgBox(2);
                return;
            }

            if(phase2CutoffTemp != phase1CutoffTemp
                    && phase.temp_flow == 0){
                phaseScanRateErrorMesgBox(2);
                return;
            }
#endif
            if (!phaseCufoffTempAndTempFlowCheck(2,
                                                 phase1CutoffTemp,
                                                 phase2CutoffTemp,
                                                 phase.temp_flow)) {
                return;
            }
        }
    }

    {
        Phase phase;
        phase.onoff                  = ui->checkBox_phase_3->checkState() ? 1 : 0;
        phase.cutoff_temp            = ui->phase_3_cutoff_temp->text().toFloat();
        phase.temp_flow              = ui->phase_3_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_3_constant_temp->text().toInt();
        phase.gas                    = conver2GasType(ui->comboBox_phase_3_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if (phase.onoff) {
            logde << "phase 3 enable.";
            phase3CutoffTemp = phase.cutoff_temp;
            if (phase3CutoffTemp < phase2CutoffTemp) {
                phaseCufoffTempErrorMesgBox(3);
                return;
            }
#if 0
            if(phase.temp_flow <= 0){
                phaseScanRateErrorMesgBox(3);
                return;
            }
#endif
            if (!phaseCufoffTempAndTempFlowCheck(3,
                                                 phase2CutoffTemp,
                                                 phase3CutoffTemp,
                                                 phase.temp_flow)) {
                return;
            }
        }
    }

    {
        Phase phase;
        phase.onoff                  = ui->checkBox_phase_4->checkState() ? 1 : 0;
        phase.cutoff_temp            = ui->phase_4_cutoff_temp->text().toFloat();
        phase.temp_flow              = ui->phase_4_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_4_constant_temp->text().toInt();
        phase.gas                    = conver2GasType(ui->comboBox_phase_4_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if (phase.onoff) {
            logde << "phase 4 enable.";
            phase4CutoffTemp = phase.cutoff_temp;
            if (phase4CutoffTemp < phase3CutoffTemp) {
                phaseCufoffTempErrorMesgBox(4);
                return;
            }
#if 0
            if(phase.temp_flow <= 0){
                phaseScanRateErrorMesgBox(4);
                return;
            }
#endif
            if (!phaseCufoffTempAndTempFlowCheck(4,
                                                 phase3CutoffTemp,
                                                 phase4CutoffTemp,
                                                 phase.temp_flow)) {
                return;
            }
        }
    }

    {
        Phase phase;
        phase.onoff                  = ui->checkBox_phase_5->checkState() ? 1 : 0;
        phase.cutoff_temp            = ui->phase_5_cutoff_temp->text().toFloat();
        phase.temp_flow              = ui->phase_5_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_5_constant_temp->text().toInt();
        phase.gas                    = conver2GasType(ui->comboBox_phase_5_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if (phase.onoff) {
            logde << "phase 5 enable.";
            phase5CutoffTemp = phase.cutoff_temp;
            if (phase5CutoffTemp < phase4CutoffTemp) {
                phaseCufoffTempErrorMesgBox(5);
                return;
            }
#if 0
            if(phase.temp_flow <= 0){
                phaseScanRateErrorMesgBox(5);
                return;
            }
#endif
            if (!phaseCufoffTempAndTempFlowCheck(5,
                                                 phase4CutoffTemp,
                                                 phase5CutoffTemp,
                                                 phase.temp_flow)) {
                return;
            }
        }
    }

    {
        Phase phase;
        phase.onoff                  = ui->checkBox_phase_6->checkState() ? 1 : 0;
        phase.cutoff_temp            = ui->phase_6_cutoff_temp->text().toFloat();
        phase.temp_flow              = ui->phase_6_scan_rate->text().toFloat();
        phase.constant_temp_time_min = (uint16_t)ui->phase_6_constant_temp->text().toInt();
        phase.gas                    = conver2GasType(ui->comboBox_phase_6_atmosphere->currentIndex());

        phaseVtr.push_back(phase);
        //
        if (phase.onoff) {
            logde << "phase 6 enable.";
            phase6CutoffTemp = phase.cutoff_temp;
            if (phase6CutoffTemp < phase5CutoffTemp) {
                phaseCufoffTempErrorMesgBox(6);
                return;
            }
#if 0
            if(phase.temp_flow <= 0){
                phaseScanRateErrorMesgBox(6);
                return;
            }
#endif
            if (!phaseCufoffTempAndTempFlowCheck(6,
                                                 phase5CutoffTemp,
                                                 phase6CutoffTemp,
                                                 phase.temp_flow)) {
                return;
            }
        }
    }
    //
    Global::ExperimentInfo &ei = Global::_experimentInfo;
    ei.sampleName              = ui->sampleNameLineEdit->text();
    ei.sampleWeight            = ui->sampleWeightLineEdit->text();
    ei.date                    = ui->dateTimeLineEdit->text();
    ei.experimentor            = ui->userLineEdit->text();

#if 0
    ei.phaseVtr = phaseVtr;
    if(ui->radioButton_OIT->isChecked()){
        ei.testType = Global::TestType::OIT;
    } else if(ui->radioButton_OIT_not->isChecked()){
        ei.testType = Global::TestType::NoneOIT;
    }

    ei.initialAtmosPhere = (GasType)(ui->comboBox_phase_1_atmosphere->currentIndex());
#endif

    // initial data.
    QByteArray initialBa;
    if (ui->radioButton_OIT->isChecked()) {
        initialBa.append((char)0);

        Global::_experimentOITFlag = true;

        logde << "Global::_experimentOITFlag = true;";
    } else {
        initialBa.append((char)1);

        Global::_experimentOITFlag = false;

        logde << "Global::_experimentOITFlag = false;";
    }

    char index = ui->comboBox_initial_atmosphere->currentIndex();
    initialBa.append(index);

    // 实验名称检查
    if (Global::isFileExist(ei.sampleName)) {
        QMessageBox::question(this, "实验名称重复", "实验名称已存在，请重新输入！",
                              QMessageBox::Yes);
        return;
    }
    //
    QByteArray ba = DataParser::setExperimentInfo(phaseVtr, initialBa);

    qDebug() << "ba size:" << ba.size();

    emit sigDeliverData(ba);
    hide();
}

void ExperimentSettingForm::slotCancel() {
    hide();
}

void ExperimentSettingForm::phaseCufoffTempErrorMesgBox(const int phaseNum) {
    QString title = QString("阶段%1截止温度错误").arg(QString::number(phaseNum));
    QString text  = QString("阶段%1截止温度不能小于上一阶段截止温度!  ").arg(QString::number(phaseNum));
    QMessageBox::question(this, title, text,
                          QMessageBox::Yes);
}

void ExperimentSettingForm::phaseScanRateErrorMesgBox(const int phaseNum) {
    QString title = QString("阶段%1扫描速率错误").arg(QString::number(phaseNum));
    QString text  = QString("阶段%1扫描速率必须大于0!  ").arg(QString::number(phaseNum));
    QMessageBox::question(this, title, text,
                          QMessageBox::Yes);
}
void ExperimentSettingForm::slotPhaseCheck() {
    if (sender() == ui->checkBox_phase_2) {
        if (ui->checkBox_phase_2->isChecked()) {
            ui->phase_2_cutoff_temp->setEnabled(true);
            ui->phase_2_scan_rate->setEnabled(true);
            ui->phase_2_constant_temp->setEnabled(true);
            ui->comboBox_phase_2_atmosphere->setEnabled(true);
        } else {
            ui->phase_2_cutoff_temp->setEnabled(false);
            ui->phase_2_scan_rate->setEnabled(false);
            ui->phase_2_constant_temp->setEnabled(false);
            ui->comboBox_phase_2_atmosphere->setEnabled(false);
        }
    } else if (sender() == ui->checkBox_phase_3) {
        if (ui->checkBox_phase_3->isChecked()) {
            ui->phase_3_cutoff_temp->setEnabled(true);
            ui->phase_3_scan_rate->setEnabled(true);
            ui->phase_3_constant_temp->setEnabled(true);
            ui->comboBox_phase_3_atmosphere->setEnabled(true);
        } else {
            ui->phase_3_cutoff_temp->setEnabled(false);
            ui->phase_3_scan_rate->setEnabled(false);
            ui->phase_3_constant_temp->setEnabled(false);
            ui->comboBox_phase_3_atmosphere->setEnabled(false);
        }
    } else if (sender() == ui->checkBox_phase_4) {
        if (ui->checkBox_phase_4->isChecked()) {
            ui->phase_4_cutoff_temp->setEnabled(true);
            ui->phase_4_scan_rate->setEnabled(true);
            ui->phase_4_constant_temp->setEnabled(true);
            ui->comboBox_phase_4_atmosphere->setEnabled(true);
        } else {
            ui->phase_4_cutoff_temp->setEnabled(false);
            ui->phase_4_scan_rate->setEnabled(false);
            ui->phase_4_constant_temp->setEnabled(false);
            ui->comboBox_phase_4_atmosphere->setEnabled(false);
        }
    }
}

void ExperimentSettingForm::slotRecvPhaseInfo(const QByteArray &ba) {
    logde << "recv phase info  ----------------------- ";

#if 1
    QString hexData = ba.toHex(' ');    // ' ' 作为分隔符，可选参数
    qDebug() << "slotRecvPhaseInfo hex:" << hexData;
#endif

    QByteArray          localba = ba;
    SerialPortProtocol *spp     = (SerialPortProtocol *)localba.data();

    u8 *data = spp->data_buf;

    int phaseSize = spp->len / PHASE_BYTE_SIZE;

    QVector<Phase> phaseVtr;
    for (int i = 0; i < phaseSize; i++) {
#if 0
        Phase *phase = (Phase *)(data + i * PHASE_BYTE_SIZE);
        phaseVtr.push_back(*phase);
#endif

#if 0
        u8* localData = data + i * PHASE_BYTE_SIZE;
        int index = 0;

        Phase phase;
        phase.onoff         = *(localData + index);
        index += 1;

        phase.cutoff_temp   = (float)*(localData + index);
        index += 4;

        phase.temp_flow     = (float)*(localData + index);
        index += 4;

        phase.constant_temp_time_min = (u16)*(localData + index);
        index += 2;

        //        phase.gas = (int)*(localData + index);
        int gasType= (u8)*(localData + index);

        switch(gasType){
        case GasType::NC:
            phase.gas = GasType::NC;
            break;
        case GasType::N2:
            phase.gas = GasType::N2;
            break;
        case GasType::O2:
            phase.gas = GasType::O2;
            break;
        default:
            break;
        }

        phaseVtr.push_back(phase);
#endif
        uint8_t *localData = data + i * PHASE_BYTE_SIZE;
        int      index     = 0;

        Phase phase;
        // 解析 onoff
        //        phase.onoff = *(localData + index);
        memcpy(&phase.onoff, localData + index, sizeof(uint8_t));
        index += sizeof(uint8_t);

        // 解析 cutoff_temp
        memcpy(&phase.cutoff_temp, localData + index, sizeof(float));
        index += sizeof(float);

        // 解析 temp_flow
        memcpy(&phase.temp_flow, localData + index, sizeof(float));
        index += sizeof(float);

        // 解析 constant_temp_time_min
        memcpy(&phase.constant_temp_time_min, localData + index, sizeof(uint16_t));
        index += sizeof(uint16_t);

        // 解析 gas
        uint8_t gasType = *(localData + index);
        switch (gasType) {
            case NC:
                phase.gas = NC;
                break;
            case N2:
                phase.gas = N2;
                break;
            case O2:
                phase.gas = O2;
                break;
            default:
                phase.gas = NC;    // 默认值，表示未知类型
                break;
        }
        phaseVtr.push_back(phase);
    }

    Global::_experimentInfo.phaseVtr = phaseVtr;

    // ui update
    //     logde<<"phaseVtr size:"<<phaseVtr.size();

    uiReset();

    for (int i = 0; i < phaseVtr.size();) {
        const Phase &phase = phaseVtr[i];
        if (phase.onoff == 0) {
            break;
        }

        i++;
        //        qDebug()<<"index :"<<i;

        QString    checkBoxName   = QString("checkBox_phase_%1").arg(i);
        QCheckBox *checkBox_phase = qobject_cast<QCheckBox *>(this->findChild<QObject *>(checkBoxName));
        if (checkBox_phase) {
            checkBox_phase->setChecked(true);
            //            qDebug()<<"found...";
        } else {
            //            qDebug()<<"not found...";
        }

        QString    cutOffTempLineEditName = QString("phase_%1_cutoff_temp").arg(i);
        QLineEdit *cutOffTempLineEdit     = qobject_cast<QLineEdit *>(this->findChild<QObject *>(cutOffTempLineEditName));
        if (cutOffTempLineEdit) {
            cutOffTempLineEdit->setText(QString::number(phase.cutoff_temp, 'f', 3));
            cutOffTempLineEdit->setEnabled(true);
        }

        QString    scanRateLineEditName = QString("phase_%1_scan_rate").arg(i);
        QLineEdit *scanRateLineEdit =
            qobject_cast<QLineEdit *>(this->findChild<QObject *>(scanRateLineEditName));
        if (scanRateLineEdit) {
            scanRateLineEdit->setText(QString::number(phase.temp_flow, 'f', 3));
            scanRateLineEdit->setEnabled(true);
        }
        QString    constantTempLineEditName = QString("phase_%1_constant_temp").arg(i);
        QLineEdit *constantTempLineEdit =
            qobject_cast<QLineEdit *>(this->findChild<QObject *>(constantTempLineEditName));
        if (constantTempLineEdit) {
            constantTempLineEdit->setText(QString::number(phase.constant_temp_time_min));
            constantTempLineEdit->setEnabled(true);
        }
        QString    atmoshpereComboBoxName = QString("comboBox_phase_%1_atmosphere").arg(i);
        QComboBox *atmoshpereComboBox =
            qobject_cast<QComboBox *>(this->findChild<QObject *>(atmoshpereComboBoxName));
        if (atmoshpereComboBox) {
            atmoshpereComboBox->setCurrentIndex(phase.gas % 256);
            atmoshpereComboBox->setEnabled(true);
        }
    }
    //
    //    radioButton_OIT_not
    //    radioButton_OIT
    //    comboBox_initial_atmosphere

    u8 *oitValue = (data + 72);
    logde << "oit value:" << (int)*oitValue;

    if (*oitValue) {
        ui->radioButton_OIT->setChecked(false);
        ui->radioButton_OIT_not->setChecked(true);
#if 0
        QString oitRadioButtonName("radioButton_OIT");
        QRadioButton *oitRadioButton =
                qobject_cast<QRadioButton*>(this->findChild<QObject*>(oitRadioButtonName));
        if(oitRadioButton){
            oitRadioButton->setChecked(true);
        }
#endif
    } else {
        ui->radioButton_OIT->setChecked(true);
        ui->radioButton_OIT_not->setChecked(false);
        Global::_experimentOITFlag = true;

        logde << "Global::_experimentOITFlag = true;";
#if 0
        QString oitNotRadioButtonName("radioButton_OIT_not");
        QRadioButton *oitNotRadioButton =
                qobject_cast<QRadioButton*>(this->findChild<QObject*>(oitNotRadioButtonName));
        if(oitNotRadioButton){
            oitNotRadioButton->setChecked(true);
        }
#endif
    }

    u8 *initAtmosphereValue = (data + 73);
    logde << "initAtmosphereValue:" << (int)(*initAtmosphereValue);
    ui->comboBox_initial_atmosphere->setCurrentIndex((int)*initAtmosphereValue);

#if 0
    QString initialAtmosphereComboBoxObjectName("comboBox_initial_atmosphere");
    QComboBox *initialAtmosphereComboBox =
            qobject_cast<QComboBox*>(this->findChild<QObject*>(initialAtmosphereComboBoxObjectName));
    if(initialAtmosphereComboBox){
        initialAtmosphereComboBox->setCurrentIndex(*initAtmosphereValue);
    }
#endif
}

void ExperimentSettingForm::showEvent(QShowEvent *event) {
    QDateTime currentDateTime     = QDateTime::currentDateTime();
    QString   internationalFormat = currentDateTime.toString("yyyy/MM/dd hh:mm:ss");

    ui->dateTimeLineEdit->setText(internationalFormat);
}
