#include "Printsetting.h"
#include "ui_Printsetting.h"

#include <QMessageBox>
#include <QDebug>
#include <QFile>
#include <QXmlStreamReader>
#include "LogInfo.h"
#include "PrintSetting.h"

PrintSetting::PrintSetting(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::PrintSetting)
{
    ui->setupUi(this);
    m_checkBtn = ui->checkBtn;
    m_closeBtn = ui->closeBtn;

    pulseNumFix = new PulseNumFix(parent);
    pulseNumFix->hide();
    ui->lineEditTriggerPulsePerMm->setValidator(new QDoubleValidator(0));
    connect(pulseNumFix,SIGNAL(pulseNuxFixDone(float)),this,SLOT(onPulseNumFixDone(float)));

    // 隐藏延时、产生脉冲所需计数、脉冲输出使能、禁止电眼清零、字符宽度、电眼清零
    ui->labelOutputPulseDelayMs->hide();
    ui->spinBoxOutputPulseDelayMs->hide();
    ui->labelProductCntPerOutputPulse->hide();
    ui->spinBoxProductCntPerOutputPulse->hide();
    ui->labelSynTriggerPrintLenRatio->hide();
    ui->spinBoxSynTriggerPrintLenRatio->hide();
    ui->checkBoxEleEyeMakeClean->hide();
    ui->spinBoxOuputPulseCol->hide();
    ui->checkBoxPulseOutputEnable->hide();
    ui->comboBoxEleEyeMakeClean->setCurrentIndex(0);
    ui->comboBoxEleEyeMakeClean->hide();

    ui->labelSynTriggerPrintLen->hide();
    ui->spinBoxSynTriggerPrintLen->hide();

    ui->labelSynPrintMode->hide();
    ui->comboBoxSynPrintMode->hide();

    // 间隔模式默认行末对行首
    ui->comboBoxTimeTriggerMode->hide();
    ui->spinBoxpluseSinal->hide();
    ui->labelTimeTriggerMode->hide();
    ui->label_6->hide();
    
    init();

    ui->eleEyeEdgetTriggerInner->click();
    ui->radioButtonSynTriggerInner->click();

    ui->tabWidget->setCurrentIndex(0);
    ui->tabWidget->removeTab(4);
}

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

void PrintSetting::init()
{
    // 应用样式表
    applyStyleSheet();

    // 连接信号槽
    connect(m_closeBtn, &QPushButton::clicked, this, &PrintSetting::buttonClickedSlot);

    connect(m_checkBtn,&QPushButton::clicked, this, &PrintSetting::buttonClickedSlot);

    connect(ui->eleEyeEdgetTriggerExternal, &QRadioButton::toggled, this, [this](bool b){
        if(b)
            on_eleEyeEdgetTriggerExternal_clicked();
    });

    connect(ui->eleEyeEdgetTriggerInner, &QRadioButton::toggled, this, [this](bool b){
        if(b)
            on_eleEyeEdgetTriggerInner_clicked();
    });

    connect(ui->radioButtonSynTriggerInner, &QRadioButton::toggled, this, [this](bool b){
        if(b)
            on_radioButtonSynTriggerInner_clicked();
    });

    connect(ui->radioButtonSynTriggerExternal, &QRadioButton::toggled, this, [this](bool b){
        if(b)
            on_radioButtonSynTriggerExternal_clicked();
    });
}

extern void MySleep(unsigned int msec);
void PrintSetting::buttonClickedSlot()
{
    QPushButton* btn = qobject_cast<QPushButton*>(sender());
    if (btn == m_closeBtn)
    {
        emit sendButtonClickedSignal(1);
    }else if(btn == m_checkBtn){
        on_pushButtonApply_pressed();
        emit sendButtonClickedSignal(2);
    }
}

void  PrintSetting::on_pushButtonApply_pressed(){
    if (m_isDefaultSettingMode) {
        updateModelFromUI();
        PrintSettingModel::setDefPrintSettingModel(m_model);
        QMessageBox::information(nullptr, tr("提示"), tr("默认设置已保存"));
    } else {
        applyPrintSettingsToSysPara(true);
    }
}

void PrintSetting::updateModelFromUI(){
    m_model.leftRightInverse = ui->checkBoxLeftRightInverse->isChecked();
    m_model.upDownInverse = ui->checkBoxUpDownInverse->isChecked();
    m_model.volParaIndex = ui->comboBox_selcetVolPara->currentIndex();
    m_model.printColDelay = ui->spinBoxColDelay->value();
    m_model.highVoltageAmplitude = ui->spinBoxHighVoltageValue->value();

    m_model.eleEyeTriggerPrintDelay = ui->spinBoxEleEyeTriggerPrintDelay->value();
    m_model.timeTriggerPrintMode = 0;
    m_model.triggerInterval = ui->spinBoxEleEyeTriggerIntervalMs->value();
    int value = 0;
    if (ui->cb_unlimited->isChecked()) 
        value = UINT16_MAX;
    else 
        value = ui->spinBoxEleEyeTriggerRepeatCnt->value();
        
    m_model.eleEyeRepeatCnt = value;
    m_model.encoderPulsePerMm = ui->lineEditTriggerPulsePerMm->text().toFloat();

    if(ui->eleEyeEdgetTriggerExternal->isChecked() && ui->radioButtonSynTriggerExternal->isChecked()) {
        m_model.triggerMode = ui->radioButtonEleEyeEdgetTrigger->isChecked() ? PRINT_TRIGGER_ELEC_EYE_EDGE : PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL;
    }
    else if(ui->eleEyeEdgetTriggerInner->isChecked() && ui->radioButtonSynTriggerInner->isChecked()) {
        m_model.triggerMode = PRINT_TRIGGER_TIME;
    }
    else if(ui->radioButtonSynTriggerExternal->isChecked() && ui->eleEyeEdgetTriggerInner->isChecked()) {
        m_model.triggerMode = PRINT_TRIGGER_SYNCHRONIZER;
    }

    // if (m_model.triggerMode == PRINT_TRIGGER_SYNCHRONIZER) {
    //     if (m_model.triggerInterval < m_model.eleEyeTriggerPrintDelay) {
    //         QMessageBox::information(nullptr, tr("提示：参数不正确"), tr("要求：触发长度小于喷印间隔"));
    //     }
    // }

    m_model.eleMaskTime = ui->spinBoxEleMaskTime->value();
    m_model.altMirrorType = ui->comboBoxAltMirrType->currentIndex();
    m_model.altMirrorGap = ui->spinBoxAltMirrorGap->value();

    m_model.syncTriggerMode = ui->comboBoxSyncActType->currentIndex();

    bool eleEyeExternal = ui->eleEyeEdgetTriggerExternal->isChecked();
    bool synExternal = ui->radioButtonSynTriggerExternal->isChecked();
    m_model.eleEyeTriggerSynPrintEn = eleEyeExternal && synExternal;

    m_model.pulseOutputEnable = ui->checkBoxPulseOutputEnable->isChecked();
    m_model.productCntPerOutputPulse = ui->spinBoxProductCntPerOutputPulse->value();
    m_model.outputPulseDelayMs = ui->spinBoxOutputPulseDelayMs->value();
    m_model.OuputPulseCol = ui->spinBoxOuputPulseCol->value();

    // if (m_model.triggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL
    //     || m_model.triggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE
    //     || m_model.triggerMode == PRINT_TRIGGER_SYNCHRONIZER) {
    //     ui->labelOutputPulseDelayMs->setText(tr("延时(毫米):"));
    // } else {
    //     ui->labelOutputPulseDelayMs->setText(tr("延时(毫秒):"));
    // }
}

void PrintSetting::bindSysPara(SysPara *sysPara)
{
    this->sysPara = sysPara;
    if (sysPara) {
        m_model = PrintSettingModel::fromSysPara(sysPara);
        updateModelToUI();
    }
}

void PrintSetting::updateModelToUI(){
    ui->checkBoxLeftRightInverse->setChecked(m_model.leftRightInverse);
    ui->checkBoxUpDownInverse->setChecked(m_model.upDownInverse);

    ui->spinBoxColDelay->setValue(m_model.printColDelay);

    ui->spinBoxHighVoltageValue->setValue(m_model.highVoltageAmplitude);

    ui->comboBox_selcetVolPara->setCurrentIndex(m_model.volParaIndex);

    TriggerupdateModelToUI();
}

void PrintSetting::TriggerupdateModelToUI()
{
    setTriggerUI(m_model.triggerMode);

    bool eleEyeInner = m_model.triggerMode != PRINT_TRIGGER_ELEC_EYE_EDGE 
                    && m_model.triggerMode != PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL;
    bool isEyeMode = (m_model.triggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE 
                   || m_model.triggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL);
    bool synInner = m_model.triggerMode != PRINT_TRIGGER_SYNCHRONIZER 
                 && !(isEyeMode && m_model.eleEyeTriggerSynPrintEn);

    if (m_model.eleEyeTriggerSynPrintEn) {
        eleEyeInner = false;
        synInner = false;
    }

    ui->eleEyeEdgetTriggerInner->setChecked(eleEyeInner);
    ui->eleEyeEdgetTriggerExternal->setChecked(!eleEyeInner);
    ui->radioButtonSynTriggerInner->setChecked(synInner);
    ui->radioButtonSynTriggerExternal->setChecked(!synInner);

    ui->spinBoxEleEyeTriggerPrintDelay->setValue(m_model.eleEyeTriggerPrintDelay);
#ifndef NON_CABLE
    ui->comboBoxTimeTriggerMode->setCurrentIndex(m_model.timeTriggerPrintMode);
#endif
    ui->spinBoxEleEyeTriggerIntervalMs->setValue(m_model.triggerInterval);
    ui->spinBoxOutputPulseDelayMs->setValue(m_model.outputPulseDelayMs);
    ui->spinBoxEleEyeTriggerRepeatCnt->setValue(m_model.eleEyeRepeatCnt);

    ui->spinBoxSynTriggerPrintLen->setText(QString::number(m_model.triggerInterval));
    ui->lineEditTriggerPulsePerMm->setText(QString::number((double)m_model.encoderPulsePerMm));

    ui->comboBoxEleEyeMakeClean->setCurrentIndex(0);

    ui->checkBoxPulseOutputEnable->setChecked(m_model.pulseOutputEnable);
    ui->spinBoxProductCntPerOutputPulse->setValue(m_model.productCntPerOutputPulse);
    ui->spinBoxOuputPulseCol->setValue(m_model.OuputPulseCol);

    ui->comboBoxSyncActType->setCurrentIndex(m_model.syncTriggerMode);

    ui->spinBoxEleMaskTime->setValue(m_model.eleMaskTime);

    ui->spinBoxAltMirrorGap->setValue(m_model.altMirrorGap);

    ui->comboBoxAltMirrType->setCurrentIndex(m_model.altMirrorType);
    ui->spinBoxpluseSinal->setValue(m_model.pulse_sinal_value);

    if (m_model.triggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE)
        ui->radioButtonEleEyeEdgetTrigger->setChecked(true);
    if (m_model.triggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL)
        ui->radioButtonEleEyeLevelTrigger->setChecked(true);
}

void PrintSetting::updateSysStatusToUI(){
}

void PrintSetting::on_pushButtonApplyPulseFix_clicked()
{
    float circle = ui->lineEditDiameter->text().toFloat() * 3.1415926;
    float pulseNum = ui->lineEditPulsePerCycle->text().toFloat();
    if(circle != 0){
        auto pulseNumPerMM = 4*pulseNum/circle; //电路和Fpga做了4倍频处理，这里乘以4是为了匹配4倍频的处理进行正确的显示
        m_model.encoderPulsePerMm = pulseNumPerMM;
        auto b = ui->lineEditTriggerPulsePerMm->blockSignals(true);
        ui->lineEditTriggerPulsePerMm->setText(QString::number(pulseNumPerMM));
        ui->lineEditTriggerPulsePerMm->blockSignals(b);
    }

    return;

    if(!sysPara)
        return;

    pulseNumFix->bindSysPara(sysPara);
    pulseNumFix->hide();
    pulseNumFix->show();
}

void PrintSetting::onPulseNumFixDone(float value){
    ui->lineEditTriggerPulsePerMm->setText(QString::number(value));
}

void PrintSetting::on_lineEditTriggerPulsePerMm_textChanged(const QString &arg1)
{
    Q_UNUSED(arg1);
    m_model.encoderPulsePerMm = ui->lineEditTriggerPulsePerMm->text().toFloat();
}

void PrintSetting::on_radioButtonDelayTrigger_pressed()
{
    setTriggerUI(PRINT_TRIGGER_TIME);
    //    emit synDisableFontWidth(false);
}

void PrintSetting::on_radioButtonEleEyeEdgetTrigger_pressed()
{
    setTriggerUI(PRINT_TRIGGER_ELEC_EYE_EDGE);

    if(ui->radioButtonSynTriggerExternal->isChecked())
        setEnableSynTriggerSetting(true);
    else
        setEnableSynTriggerSetting(false);
    //    emit synDisableFontWidth(false);
}

void PrintSetting::on_radioButtonEleEyeLevelTrigger_pressed()
{
    setTriggerUI(PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL);

    if(ui->radioButtonSynTriggerExternal->isChecked())
        setEnableSynTriggerSetting(true);
    else
        setEnableSynTriggerSetting(false);
    //    emit synDisableFontWidth(false);
}

void PrintSetting::on_radioButtonSynTrigger_pressed()
{
    setTriggerUI(PRINT_TRIGGER_SYNCHRONIZER);
    //edit@11-19
    //    const unsigned short &FpgaVer=sysPara->status.build_dat.builTime;
    //    //72版本禁用字符宽度
    //    if(72 == FpgaVer){
    //        ui->spinBoxSynTriggerPrintLenRatio->setValue(0);
    //        ui->spinBoxSynTriggerPrintLenRatio->setEnabled(0);
    //    }else if (67 == FpgaVer)
    //        ui->spinBoxSynTriggerPrintLenRatio->setEnabled(1);
    //    emit synDisableFontWidth(true);

}

void PrintSetting::on_checkEyeTriggerSynPrintEn_clicked(bool checked)
{
    // ui->cb_unlimited->setEnabled(checked);
    if(sysPara)
    {
        int triggerMode = m_model.triggerMode;
        if( checked)
        {
#ifndef NON_CABLE
            // ui->spinBoxSynTriggerPrintLen->setEnabled(1);
#endif
            // ui->labelSynTriggerPrintLen->setEnabled(1);
            // ui->lineEditTriggerPulsePerMm->setEnabled(1);
            // ui->labelTriggerPulsePerMm->setEnabled(1);
            // ui->spinBoxSynTriggerPrintLenRatio->setEnabled(1);
            // ui->labelSynTriggerPrintLenRatio->setEnabled(1);
            // ui->checkBoxEleEyeMakeClean->setEnabled(1);
            // ui->pushButtonApplyPulseFix->setEnabled(1);
            // ui->comboBoxSynPrintMode->setEnabled(1);
            // ui->labelSynPrintMode->setEnabled(1);
            // ui->spinBoxEleEyeTriggerIntervalMs->setEnabled(0);
            ui->labelEleEyeTriggerPrintDelay->setText(tr("触发延时(毫米)"));
            ui->labelEleEyeTriggerIntervalMs->setText(tr("重复间隔(毫米)"));
            ui->labelEleMaskTime->setText(tr("抑止距离(毫米)"));
            ui->labelOutputPulseDelayMs->setText(tr("延时(毫米):"));
            if(ui->comboBoxSyncActType->currentIndex() >= ui->comboBoxSyncActType->count() || ui->comboBoxSyncActType->currentIndex() == -1) //如果不是在正反转打印的模式下，就切换到正反转模式
            {
                ui->comboBoxSyncActType->setCurrentIndex(0);
            }
        }
        else
        {
#ifndef NON_CABLE
            // ui->spinBoxSynTriggerPrintLen->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
#endif
            // ui->labelSynTriggerPrintLen->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
            // ui->lineEditTriggerPulsePerMm->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
            // ui->labelTriggerPulsePerMm->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
            // ui->spinBoxSynTriggerPrintLenRatio->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
            // ui->labelSynTriggerPrintLenRatio->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
            // ui->checkBoxEleEyeMakeClean->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
            // ui->pushButtonApplyPulseFix->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
            // ui->comboBoxSynPrintMode->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
            // ui->labelSynPrintMode->setEnabled(triggerMode == PRINT_TRIGGER_SYNCHRONIZER);
            // ui->spinBoxEleEyeTriggerIntervalMs->setEnabled(1);
            ui->labelEleEyeTriggerPrintDelay->setText(tr("触发延时(毫秒)"));
            ui->labelEleEyeTriggerIntervalMs->setText(tr("重复间隔(毫秒)"));
            ui->labelEleMaskTime->setText(tr("抑止距离(毫秒)"));
        }
    }
}

void PrintSetting::setTriggerUI(int triggerMode){
    m_model.triggerMode = triggerMode;

    // ui->sb_printingDelay->setEnabled(triggerMode == PRINT_TRIGGER_TIME);
    // ui->lb_printingDelay->setEnabled(triggerMode == PRINT_TRIGGER_TIME);

    ui->radioButtonEleEyeEdgetTrigger->setChecked( triggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE);
    ui->radioButtonEleEyeLevelTrigger->setChecked(triggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL);

    if(m_model.eleEyeTriggerSynPrintEn &&
            (triggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL || triggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE)
            )
    {
        ui->labelEleEyeTriggerPrintDelay->setText(tr("触发延时(毫米)"));
        ui->labelEleEyeTriggerIntervalMs->setText(tr("重复间隔(毫米)"));
        ui->labelEleMaskTime->setText(tr("抑止距离(毫米)"));
    }
    else
    {
        if(triggerMode == PRINT_TRIGGER_SYNCHRONIZER)
        {
            ui->labelEleEyeTriggerPrintDelay->setText(tr("触发延时(毫米)"));
            ui->labelEleEyeTriggerIntervalMs->setText(tr("重复间隔(毫米)"));
        }
        else
        {
            ui->labelEleEyeTriggerPrintDelay->setText(tr("触发延时(毫秒)"));
            ui->labelEleEyeTriggerIntervalMs->setText(tr("重复间隔(毫秒)"));
        }
        ui->labelEleMaskTime->setText(tr("封锁时间(毫秒)"));
    }
    if(triggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL
         || triggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE
            || triggerMode == PRINT_TRIGGER_SYNCHRONIZER  )
    {
        ui->labelOutputPulseDelayMs->setText(tr("延时(毫米):"));
    }
    else ui->labelOutputPulseDelayMs->setText(tr("延时(毫秒):"));

    setSynPrintMode(SYN_PRINT_MODE_ACCORDING_CHAR_WIDTH);
}

void PrintSetting::setSynPrintMode(int mode){
    ui->labelSynTriggerPrintLenRatio->setText((mode == SYN_PRINT_MODE_ACCORDING_CHAR_WIDTH)?tr("字符宽度"):tr("喷印比例(%)"));
    ui->comboBoxSynPrintMode->setCurrentIndex(mode);

    const bool bShow = SYN_PRINT_MODE_ACCORDING_CHAR_WIDTH != mode;
    //隐藏文本框
    ui->labelSynTriggerPrintLenRatio->setVisible(false);
    //隐藏输入框
    ui->spinBoxSynTriggerPrintLenRatio->setVisible(false);
}

void PrintSetting::applyStyleSheet()
{
    QString styleSheet =
            R"(
            QTabWidget {
            border: none;
            background-color: #7B838E;
            }

            QTabBar::tab:focus {
            outline: none;
            }

            QTabBar::tab {
            min-width: 90px;
            min-height: 45px;
            padding: 4px 10px;
            margin-right: 4px;
            border: 1px solid #dddddd;
            border-bottom: none;
            border-top-left-radius: 4px;
            border-top-right-radius: 4px;
            background-color: #5396C1;
            color: #ffffff;
            }

            QTabBar::tab:selected {
            background-color: #6bb1e0;
            color: #ffffff;
            box-shadow: 0 -3px 8px rgba(44, 125, 232, 0.25);
            }

            QTabWidget::tab-bar {
            top: -3px;
            left: 10px;
            }

            QWidget#buttonWidget {
            background-color: #95989D;
            }

            QPushButton#closeBtn {
            background-color: #E6F7FF;
            border: 1px solid #87CEEB;
            border-radius: 4px;
            font-size: 24px;
            color: #228B22;
            }

            QPushButton#closeBtn:hover {
            background-color: #D1E9FF;
            }

            QPushButton#closeBtn:pressed {
            background-color: #BAE7FF;
            }

            QPushButton#checkBtn {
            background-color: #E6F7FF;
            border: 1px solid #87CEEB;
            border-radius: 4px;
            font-size: 24px;
            color: #228B22;
            }

            QPushButton#checkBtn:hover {
            background-color: #D1E9FF;
            }

            QPushButton#checkBtn:pressed {
            background-color: #BAE7FF;
            }

            QLabel {
            font-size: 18px;
            color: #000000;
            font-weight: 500;
            }

            QCheckBox {
            font-size: 18px;
            color: #000000;
            font-weight:500;
            }

            QCheckBox::indicator {
            width: 18px;
            height: 18px;
            border: 1px solid #96A0A9;
            border-radius: 10px;
            background-color: #ffffff;
            }

            QCheckBox::indicator:checked {
            background-color: #95B2D4;
            border-color: #95B2D4;
            image: url(:/Demo/image/select.png);
            }

            QPushButton {
            background-color: #5396C1;
            color: #ffffff;
            border: 1px solid #000000;
            border-radius: 3px;
            font-size: 18px;
            font-weight:500;
            }

            QPushButton:hover {
            background-color: #5396C1;
            }

            QPushButton:disabled {
            background-color: #7C828E;
            color: #606060;
            border-color: #808080;
            }

            QWidget#fileTab, QWidget#extraTab, QWidget#settingsTab, QWidget#serviceTab {
            background-color: #E3E7EC;
            }

            QRadioButton {
            background-color: rgb(192, 205, 210);
            border-radius: 5px;
            padding-left: 5px;
            }
            )";

    this->setStyleSheet(styleSheet);
}

void PrintSetting::on_eleEyeEdgetTriggerInner_clicked()
{
    setEnableEleEyeSetting(false);

    if (sysPara == NULL) return;

    if(ui->radioButtonSynTriggerInner->isChecked()){
        m_model.triggerMode = PRINT_TRIGGER_TIME;
    }else
        m_model.triggerMode = PRINT_TRIGGER_SYNCHRONIZER;

    m_model.eleEyeTriggerSynPrintEn = false;
    on_checkEyeTriggerSynPrintEn_clicked(false);

    setTriggerUI(m_model.triggerMode);
}

void PrintSetting::setEnableEleEyeSetting(bool flag){

    ui->labelEleEyeTriggerIntervalMs->setEnabled(!(ui->radioButtonSynTriggerExternal->isChecked() && ui->eleEyeEdgetTriggerInner->isChecked()));
    // ui->spinBoxEleEyeTriggerIntervalMs->setEnabled(!(ui->radioButtonSynTriggerExternal->isChecked() && ui->eleEyeEdgetTriggerInner->isChecked()));
    ui->spinBoxEleMaskTime->setEnabled(flag);
    ui->spinBoxEleEyeTriggerRepeatCnt->setEnabled(flag);
    ui->radioButtonEleEyeEdgetTrigger->setEnabled(flag);
    ui->radioButtonEleEyeLevelTrigger->setEnabled(flag);
    ui->cb_unlimited->setEnabled(flag);
    ui->spinBoxEleEyeTriggerPrintDelay->setEnabled(flag);
    if (!flag) ui->cb_unlimited->setChecked(false);
}

void PrintSetting::on_eleEyeEdgetTriggerExternal_clicked()
{
    m_model.eleEyeTriggerSynPrintEn = ui->radioButtonSynTriggerExternal->isChecked();
    on_checkEyeTriggerSynPrintEn_clicked(m_model.eleEyeTriggerSynPrintEn);

    if(ui->radioButtonEleEyeEdgetTrigger->isChecked())
        m_model.triggerMode = PRINT_TRIGGER_ELEC_EYE_EDGE;
    else
        m_model.triggerMode = PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL;

    setEnableEleEyeSetting(true);
    setTriggerUI(m_model.triggerMode);
}

void PrintSetting::setEnableSynTriggerSetting(bool flag){

    // ui->labelTriggerPulsePerMm->setEnabled(flag);
    ui->lineEditTriggerPulsePerMm->setEnabled(flag);
    ui->pushButtonApplyPulseFix->setEnabled(flag);
    // ui->labelSynTriggerPrintLen->setEnabled(flag);
    ui->spinBoxSynTriggerPrintLen->setEnabled(flag);
    ui->comboBoxSyncActType->setEnabled(flag);
    // ui->labelSynPrintMode->setEnabled(flag);
    ui->comboBoxSynPrintMode->setEnabled(flag);
}

void PrintSetting::applyPrintSettingsToSysPara(bool showTip)
{
    if(!sysPara)
        return;

    updateModelFromUI();
    PrintSettingModel::applyToSysPara(m_model, sysPara);

    if (sysPara->devOp) {
        sysPara->devOp->setHighVoltageAmplitudetoSTM32();
        sysPara->devOp->writeFpgaCalandar(0);
        sysPara->devOp->writeFlightCompCtrl(ui->enbFlightCompCtrl->isChecked(), 
            ui->enbAccelDecelPredict->isChecked(), quint32(ui->flightCompWindowCycles->value()));

        if(sysPara->devOp->writeFpgaPrintPara(true) != -1 && showTip) {
            QMessageBox box(QMessageBox::Icon::Information, tr("提示"), tr("应用成功"), QMessageBox::Ok, nullptr);
            auto btn = box.button(QMessageBox::Ok);
            // btn->setFixedSize(80, 40);

            box.exec();
        }
    }

    if(sysPara)
        sysPara->saveParaToFile ();
}

PrintSettingModel PrintSetting::model() const
{
    return m_model;
}

void PrintSetting::setModel(const PrintSettingModel &model)
{
    m_model = model;
    updateModelToUI();

    LogInfo::setRunStatusText("Print settings: " + PrintSettingModel::toString(model));
}

void PrintSetting::setDefaultSettingMode(bool enable)
{
    m_isDefaultSettingMode = enable;
}

void PrintSetting::on_radioButtonSynTriggerInner_clicked()
{
    setEnableSynTriggerSetting(false);
    if (sysPara == NULL) return;
    if(ui->eleEyeEdgetTriggerInner->isChecked()){
        m_model.triggerMode = PRINT_TRIGGER_TIME;
        setTriggerUI(m_model.triggerMode);
    }
    m_model.eleEyeTriggerSynPrintEn = false;
    on_checkEyeTriggerSynPrintEn_clicked(false);

    setEnableEleEyeSetting(!ui->eleEyeEdgetTriggerInner->isChecked());
}

void PrintSetting::on_radioButtonSynTriggerExternal_clicked()
{
    if(!ui->eleEyeEdgetTriggerExternal->isChecked()){
        m_model.triggerMode = PRINT_TRIGGER_SYNCHRONIZER;
    }
    else {
        m_model.triggerMode = ui->radioButtonEleEyeEdgetTrigger->isChecked() ? PRINT_TRIGGER_ELEC_EYE_EDGE : PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL;
    }

    m_model.eleEyeTriggerSynPrintEn = ui->eleEyeEdgetTriggerExternal->isChecked();
    
    on_checkEyeTriggerSynPrintEn_clicked(m_model.eleEyeTriggerSynPrintEn);
    setEnableSynTriggerSetting(true);
    setEnableEleEyeSetting(!ui->eleEyeEdgetTriggerInner->isChecked());
    setTriggerUI(m_model.triggerMode);
}

void PrintSetting::on_radioButtonEleEyeEdgetTrigger_clicked()
{
    m_model.triggerMode = PRINT_TRIGGER_ELEC_EYE_EDGE;
}

void PrintSetting::on_radioButtonEleEyeLevelTrigger_clicked()
{
    m_model.triggerMode = PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL;
}


void PrintSetting::on_checkBoxPulseOutputEnable_clicked(bool checked)
{
    isPulseEenable = checked;
    // ui->spinBoxOutputPulseDelayMs->setEnabled(checked);
}

void PrintSetting::on_cb_unlimited_clicked(bool checked)
{
    // ui->spinBoxEleEyeTriggerRepeatCnt->setEnabled(!checked);
}

void PrintSettingModel::loadFromXml(PrintSettingModel& model, const QXmlStreamAttributes& attrs)
{
    model.timeTriggerPrintMode = attrs.value("timeTriggerPrintMode").toInt();
    model.triggerInterval = attrs.value("triggerInterval").toUInt();
    model.eleEyeRepeatCnt = attrs.value("eleEyeRepeatCnt").toUInt();
    model.triggerMode = attrs.value("triggerMode").toUInt();
    model.encoderPulsePerMm = attrs.value("encoderPulsePerMm").toFloat();
    model.printColDelay = attrs.value("printColDelay").toUInt();
    model.volParaIndex = (unsigned short)attrs.value("volParaIndex").toUInt();
    model.eleEyeTriggerPrintDelay = (unsigned short)attrs.value("eleEyeTriggerPrintDelay").toUInt();
    model.altMirrorGap = (unsigned short)attrs.value("altMirrorGap").toUInt();
    model.eleMaskTime = (unsigned short)attrs.value("eleMaskTime").toUInt();
    model.syncTriggerMode = (unsigned char)attrs.value("syncTriggerMode").toUInt();
    model.mode0211 = (unsigned char)attrs.value("mode0211").toUInt();
    model.highVoltageAmplitude = (unsigned char)attrs.value("highVoltageAmplitude").toUInt();
    model.altMirrorType = (unsigned char)attrs.value("altMirrorType").toUInt();
    model.pulseOutputEnable = (unsigned char)attrs.value("pulseOutputEnable").toUInt();
    model.productCntPerOutputPulse = attrs.value("productCntPerOutputPulse").toUInt();
    model.outputPulseDelayMs = (unsigned short)attrs.value("outputPulseDelayMs").toUInt();
    model.OuputPulseCol = (unsigned short)attrs.value("OuputPulseCol").toUInt();
    model.pulse_sinal_value = (unsigned short)attrs.value("pulse_sinal_value").toUInt();
    model.leftRightInverse = attrs.value("leftRightInverse").toInt() != 0;
    model.upDownInverse = attrs.value("upDownInverse").toInt() != 0;
    model.eleEyeTriggerSynPrintEn = attrs.value("eleEyeTriggerSynPrintEn").toInt() != 0;
}

void PrintSettingModel::saveToXml(const PrintSettingModel& model, QXmlStreamWriter& writer)
{
    writer.writeAttribute("timeTriggerPrintMode", QString::number(model.timeTriggerPrintMode));
    writer.writeAttribute("triggerInterval", QString::number(model.triggerInterval));
    writer.writeAttribute("eleEyeRepeatCnt", QString::number(model.eleEyeRepeatCnt));
    writer.writeAttribute("triggerMode", QString::number(model.triggerMode));
    writer.writeAttribute("encoderPulsePerMm", QString::number((double)model.encoderPulsePerMm));
    writer.writeAttribute("printColDelay", QString::number(model.printColDelay));
    writer.writeAttribute("volParaIndex", QString::number(model.volParaIndex));
    writer.writeAttribute("eleEyeTriggerPrintDelay", QString::number(model.eleEyeTriggerPrintDelay));
    writer.writeAttribute("altMirrorGap", QString::number(model.altMirrorGap));
    writer.writeAttribute("eleMaskTime", QString::number(model.eleMaskTime));
    writer.writeAttribute("syncTriggerMode", QString::number(model.syncTriggerMode));
    writer.writeAttribute("mode0211", QString::number(model.mode0211));
    writer.writeAttribute("highVoltageAmplitude", QString::number(model.highVoltageAmplitude));
    writer.writeAttribute("altMirrorType", QString::number(model.altMirrorType));
    writer.writeAttribute("pulseOutputEnable", QString::number(model.pulseOutputEnable));
    writer.writeAttribute("productCntPerOutputPulse", QString::number(model.productCntPerOutputPulse));
    writer.writeAttribute("outputPulseDelayMs", QString::number(model.outputPulseDelayMs));
    writer.writeAttribute("OuputPulseCol", QString::number(model.OuputPulseCol));
    writer.writeAttribute("pulse_sinal_value", QString::number(model.pulse_sinal_value));
    writer.writeAttribute("leftRightInverse", QString::number(model.leftRightInverse));
    writer.writeAttribute("upDownInverse", QString::number(model.upDownInverse));
    writer.writeAttribute("eleEyeTriggerSynPrintEn", QString::number(model.eleEyeTriggerSynPrintEn));
}

void PrintSettingModel::applyToSysPara(const PrintSettingModel &model, SysPara *sysPara)
{
    // 喷印风格相关
    sysPara->para.leftRightInverse = model.leftRightInverse;
    sysPara->para.upDownInverse = model.upDownInverse;
    sysPara->para.currSelectVolPara = model.volParaIndex;
    sysPara->para.printColDelay = model.printColDelay;
    sysPara->para.HighVoltageAmplitude = model.highVoltageAmplitude;

    sysPara->para.mode0211 = model.mode0211;

    sysPara->para.printTriggerMode = model.triggerMode;

    sysPara->para.eleEyeTriggerPrintDelay = model.eleEyeTriggerPrintDelay;

    sysPara->para.timeTriggerPrintMode = model.timeTriggerPrintMode;
    sysPara->para.elecEyeTriggerInterval = model.triggerInterval;
    sysPara->para.photoElectricityRepeateNum = model.eleEyeRepeatCnt;
    sysPara->para.synTriggerPrintLenMm = (float)model.triggerInterval;
    sysPara->para.synPulseNumPerMm = model.encoderPulsePerMm;
    sysPara->para.sysTriggerPrintMode = SYN_PRINT_MODE_ACCORDING_CHAR_WIDTH;
    sysPara->para.AltMirrorGap = (model.altMirrorType << 12) | ((uint32_t)(model.altMirrorGap) & 0x0fff);
    sysPara->para.printDelayMs = (int)model.triggerInterval;
    
    sysPara->para.eleEyeTriggerSynPrintEn = model.eleEyeTriggerSynPrintEn;

    // 韩国版本不需要电眼清零 byons@2026年6月23日
    sysPara->para.eleEyeClearCntInSynMode = 0x20;

    sysPara->para.syncRevCompDisable = 0;
    sysPara->para.synPulsePerMmX8 = (unsigned short)((unsigned int)sysPara->para.synPulseNumPerMm <<8);
    sysPara->para.eleMaskTime = model.eleMaskTime;

    // 带补偿的正反转打印选项，位于最后两个comboBox item
    sysPara->para.synchronizorActType = model.syncTriggerMode > 2 ? 
        model.syncTriggerMode - 2 : model.syncTriggerMode;

    sysPara->para.syncRevCompDisable = model.syncTriggerMode <= 2;

    sysPara->para.pulseOutputEnable = model.pulseOutputEnable;
    sysPara->para.productCntPerOutputPulse = model.productCntPerOutputPulse;
    sysPara->para.outputPulseDelayMs = model.outputPulseDelayMs;
    sysPara->para.OuputPulseCol = model.OuputPulseCol;
    sysPara->para.pulse_sinal_value = model.pulse_sinal_value;

    sysPara->para.eleEyeEdgetTriggerInner = 
        model.triggerMode != PRINT_TRIGGER_ELEC_EYE_EDGE 
        && model.triggerMode != PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL;

    sysPara->para.eleEyeEdgetTriggerExternal = !sysPara->para.eleEyeEdgetTriggerInner;

    bool isEyeMode = (model.triggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE 
                   || model.triggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL);
    sysPara->para.synTriggerInner = 
        model.triggerMode != PRINT_TRIGGER_SYNCHRONIZER 
        && !(isEyeMode && model.eleEyeTriggerSynPrintEn);

    sysPara->para.synTriggerExternal = !sysPara->para.synTriggerInner;
}

PrintSettingModel PrintSettingModel::fromSysPara(SysPara *sysPara)
{
    PrintSettingModel model;
    if(!sysPara)
        return model;

    model.leftRightInverse = sysPara->para.leftRightInverse;
    model.upDownInverse = sysPara->para.upDownInverse;
    model.mode0211 = sysPara->para.mode0211;
    model.printColDelay = sysPara->para.printColDelay;
    model.highVoltageAmplitude = sysPara->para.HighVoltageAmplitude;
    model.volParaIndex = sysPara->para.currSelectVolPara;
    
    model.triggerMode = sysPara->para.printTriggerMode;
    model.eleEyeTriggerSynPrintEn = sysPara->para.eleEyeTriggerSynPrintEn;
    model.eleMaskTime = sysPara->para.eleMaskTime;

    int idx = int(sysPara->para.synchronizorActType);
    if (!sysPara->para.syncRevCompDisable && sysPara->para.synchronizorActType != 0) {
        idx = int(sysPara->para.synchronizorActType) + 2;
    }
    model.syncTriggerMode = idx;
    
    if(sysPara->para.printTriggerMode == PRINT_TRIGGER_ELEC_EYE_EDGE || 
        sysPara->para.printTriggerMode == PRINT_TRIGGER_ELEC_EYE_VOLTATE_LEVEL) {
            model.triggerInterval = (unsigned)sysPara->para.elecEyeTriggerInterval;
    }
    else if(sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER) {
        model.triggerInterval = (unsigned)sysPara->para.synTriggerPrintLenMm;
    }
    else {
        model.triggerInterval = (unsigned)sysPara->para.printDelayMs;
    }

    model.timeTriggerPrintMode = sysPara->para.timeTriggerPrintMode;
    model.eleEyeRepeatCnt = sysPara->para.photoElectricityRepeateNum;
    model.eleEyeTriggerPrintDelay = sysPara->para.eleEyeTriggerPrintDelay;
    model.encoderPulsePerMm = sysPara->para.synPulseNumPerMm;
    model.altMirrorType = sysPara->para.AltMirrorGap >> 12;
    model.altMirrorGap = sysPara->para.AltMirrorGap & 0x0fff;

    model.pulseOutputEnable = sysPara->para.pulseOutputEnable;
    model.productCntPerOutputPulse = sysPara->para.productCntPerOutputPulse;
    model.outputPulseDelayMs = sysPara->para.outputPulseDelayMs;
    model.OuputPulseCol = sysPara->para.OuputPulseCol;
    model.pulse_sinal_value = sysPara->para.pulse_sinal_value;

    return model;
}

QString PrintSettingModel::toString(const PrintSettingModel &model)
{
    QString str = QString::asprintf("LRInverse: %d, UpDownInverse: %d, printColDelay: %d, \r\n"
                        "highVoltageAmplitude: %d, volParaIndex: %d, triggerMode: %d, eleEyeTriggerSynPrintEn: %d, \r\n"
                        "eleMaskTime: %d, triggerInterval: %d, timeTriggerPrintMode: %d, eleEyeRepeatCnt: %d,  \r\n"
                        "eleEyeTriggerPrintDelay: %d, encoderPulsePerMm: %d, altMirrorType: %d, altMirrorGap: %d. \r\n",
                    model.leftRightInverse, model.upDownInverse, model.printColDelay, model.highVoltageAmplitude, model.volParaIndex, model.triggerMode,
                    model.eleEyeTriggerSynPrintEn, model.eleMaskTime, model.triggerInterval, model.timeTriggerPrintMode, model.eleEyeRepeatCnt,
                    model.eleEyeTriggerPrintDelay, model.encoderPulsePerMm, model.altMirrorType, model.altMirrorGap);
    return str;
}


PrintSettingModel PrintSettingModel::defPrintSettingModel()
{
    QFile file(DEF_PRINT_SETTINGS_PATH);
    if (!file.open(QIODevice::ReadOnly)) {
        return PrintSettingModel();
    }

    QXmlStreamReader reader(&file);
    PrintSettingModel model;

    if (reader.readNextStartElement() && reader.name() == QStringLiteral("PrintSettings")) {
        loadFromXml(model, reader.attributes());
    }

    file.close();
    return model;
}

void PrintSettingModel::setDefPrintSettingModel(const PrintSettingModel &model)
{
    QFile file(DEF_PRINT_SETTINGS_PATH);
    if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
        qWarning() << "Failed to open" << DEF_PRINT_SETTINGS_PATH << "for writing";
        return;
    }

    QXmlStreamWriter writer(&file);
    writer.setAutoFormatting(true);
    writer.writeStartDocument();
    writer.writeEmptyElement("PrintSettings");
    saveToXml(model, writer);
    writer.writeEndDocument();

    file.close();
}