JSBTDieBondH/View/die-bonder-ui/Src/RewriteControl/LightJoystickSwitchPage.cpp

#include "LightJoystickSwitchPage.h"
#include "ui_LightJoystickSwitchPage.h"
#include "../common/JMessageTip.h"
#include "../common/JQCommon.h"
#include <QHash>
#include <utility>

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

    InitForm();
}

LightJoystickSwitchPage::~LightJoystickSwitchPage()
{

    killTimer(m_nUpdateUiAxis);

    delete ui;
}

void LightJoystickSwitchPage::InitForm()
{
    m_nTimeShowPos = startTimer(900);
    m_nUpdateUiAxis = startTimer(900);

    InitLineEdits();
    SliderBind();

   // JQCommon::SetQLineEditLimit(ui->valLineEdit);
}


void LightJoystickSwitchPage::SliderBind()
{
    connect(ui->RedLightverticalSlider, &QSlider::valueChanged, ui->RedLightprogressBar, &QProgressBar::setValue);
    connect(ui->BlueLightverticalSlider, &QSlider::valueChanged, ui->BlueLightprogressBar, &QProgressBar::setValue);
    connect(ui->GreenLightverticalSlider, &QSlider::valueChanged, ui->GreenLightprogressBar, &QProgressBar::setValue);
    connect(ui->DotLightverticalSlider, &QSlider::valueChanged, ui->DotLightprogressBar, &QProgressBar::setValue);

    
    BondSliderAndLineEdit(ui->RedLightverticalSlider, ui->RedLightlineEdit);
    BondSliderAndLineEdit(ui->GreenLightverticalSlider, ui->GreenLightlineEdit);
    BondSliderAndLineEdit(ui->BlueLightverticalSlider, ui->BlueLightlineEdit);
    BondSliderAndLineEdit(ui->DotLightverticalSlider, ui->DotLightlineEdit);
}

void LightJoystickSwitchPage::InitLineEdits()
{
    ui->switchTabWidget->tabBar()->hide();
    QList<QLineEdit*> lineEdits = {
        ui->RedLightlineEdit, ui->GreenLightlineEdit,
        ui->BlueLightlineEdit, ui->DotLightlineEdit,
    };

    for (QLineEdit* lineEdit : lineEdits) 
    {   
        QRegExp regExp("^(0|([1-9]\\d?)|(1\\d{2})|(2[0-5]\\d))$");
        QRegExpValidator* validator = new QRegExpValidator(regExp, lineEdit);
        lineEdit->setValidator(validator);
        lineEdit->setAlignment(Qt::AlignCenter);
    }
}

void LightJoystickSwitchPage::UpDataAxisToUi()
{
    if (m_pCameraBind)
    {
        const QHash<QString, QLayout*> axisToLayout = {
            {"FORCE", ui->forceLayout},
            {"X", ui->xLayout},
            {"Y", ui->yLayout},
            {"R", ui->rLayout},
            {"Z", ui->zLayout},
            {"Z1", ui->zLayout}
        };
        for (const auto& val : m_listCurrentShowAxis) 
        {
            if (axisToLayout.contains(val))
            {
                QLayout* layout = axisToLayout.value(val);
                for (int i = 0; i < layout->count(); ++i) 
                {
                    QWidget* widget = layout->itemAt(i)->widget();
                    if (widget && widget->inherits("QLineEdit")) 
                    {
                        JReLineEdit* lineEdit = qobject_cast<JReLineEdit*>(widget);
                        if (lineEdit)
                        {
                            double pos = 0;
                            m_pCameraBind->YGetAxisPosition(m_moveAxisInfo.ModuleType, val.toStdString(), pos);
                            lineEdit->setText(QString::number(pos, 'f', 2));
                        }
                    }
                }
            }
        }     
    }
}

void LightJoystickSwitchPage::MoveModule(const QString strAxis, const QString pos)
{
    if (m_pCameraBind)
    {
        const QHash<QString, QLayout*> m_HaAxisToLayout = {
            {"FORCE", ui->forceLayout},
            {"X", ui->xLayout},
            {"Y", ui->yLayout},
            {"R", ui->rLayout},
            {"Z", ui->zLayout},
            {"Z1", ui->zLayout}
        };

        if (m_HaAxisToLayout.contains(strAxis))
        {
            QLayout* layout = m_HaAxisToLayout.value(strAxis);
            for (int i = 0; i < layout->count(); ++i)
            {
                QWidget* widget = layout->itemAt(i)->widget();
                if (widget && widget->inherits("QLineEdit"))
                {
                    JReLineEdit* lineEdit = qobject_cast<JReLineEdit*>(widget);
                    if (lineEdit)
                    {
                        if (lineEdit->m_isSetVal)
                        {
                            std::thread run([&, strAxis, pos]()
                                {
                                
                                // 目前没有测试多轴，多轴在用
                                std::vector<ns_module::MODULE_COORD_MOVE> vecPos;
                                vecPos.push_back({ strAxis.toStdString() ,pos.toDouble() });
                                m_pCameraBind->JModuleMove(ui->modeComboBox->currentText().toStdString(), vecPos, false);
                                });
                            run.detach();
                           
                        }
                    }
                }
            }
        }



        //std::thread runFun([&, strAxis, pos]() {

        //    auto LoopFun = [&](const QHash<QString, QLayout*> lay, bool isDisable)
        //    {
        //        for (auto it = lay.begin(); it != lay.end(); ++it)
        //        {
        //            const QString& key = it.key();
        //            QLayout* layout = it.value();
        //            DisableLayoutWidgets(layout, isDisable);
        //        }
        //    };

        //    const QHash<QString, QLayout*> m_HaAxisToLayout = {
        //    {"FORCE", ui->forceLayout},
        //    {"X", ui->xLayout},
        //    {"Y", ui->yLayout},
        //    {"R", ui->rLayout},
        //    {"Z", ui->zLayout},
        //    {"Z1", ui->zLayout}
        //    };
        //    //LoopFun(m_HaAxisToLayout, false);



        //    if (m_HaAxisToLayout.contains(strAxis))
        //    {
        //        QLayout* layout = m_HaAxisToLayout.value(strAxis);
        //        for (int i = 0; i < layout->count(); ++i)
        //        {
        //            QWidget* widget = layout->itemAt(i)->widget();
        //            if (widget && widget->inherits("QLineEdit"))
        //            {
        //                JReLineEdit* lineEdit = qobject_cast<JReLineEdit*>(widget);
        //                if (lineEdit)
        //                {
        //                    if (lineEdit->m_isSetVal)
        //                    {

        //                        m_pCameraBind->SetModuleMove(
        //                            ui->modeComboBox->currentText().toStdString(),
        //                            strAxis.toStdString(),
        //                            pos.toDouble(), false);


        //                        //// 目前没有测试多轴，多轴在用 ,没有多轴的情况
        //                        //std::vector<ns_module::MODULE_COORD_MOVE> vecPos;
        //                        //vecPos.push_back({ strAxis.toStdString() ,pos.toDouble() });
        //                        //m_pCameraBind->JModuleMove(ui->modeComboBox->currentText().toStdString(), vecPos, false);
        //                    }
        //                }
        //            }
        //        }
        //    }

        //    //LoopFun(m_HaAxisToLayout, true);
        //    });
    }
}

void LightJoystickSwitchPage::DisableLayoutWidgets(QLayout* layout, bool isShow /*= false*/)
{
    for (int i = 0; i < layout->count(); ++i) 
    {
        QLayoutItem* item = layout->itemAt(i);
        if (item->widget()) 
        {
            item->widget()->setEnabled(isShow);
        }
        else if (item->layout()) 
        {
            DisableLayoutWidgets(item->layout());
        }
    }
}

void LightJoystickSwitchPage::AdjustComboBoxWidth(QComboBox* comboBox)
{
    if (!comboBox || comboBox->count() == 0) return;

    // 获取字体度量
    QFontMetrics metrics(comboBox->font());
    int max_width = 0;

    // 遍历所有项目
    for (int i = 0; i < comboBox->count(); ++i) 
    {
        const QString text = comboBox->itemText(i);
        max_width = qMax(max_width, metrics.horizontalAdvance(text));
    }


    comboBox->setMinimumWidth(max_width); 
}

template<class T>
void LightJoystickSwitchPage::DeduplicationBox(QComboBox* pCom, const T& veTemp, int nIndex)
{
    for (auto& a : veTemp)
    {
        QString strName;
        if (nIndex == 0)
        {
            strName = a->GetModuleType().c_str();
        }
        else if (nIndex == 1)
        {
            strName = a->GetStringAxisType().c_str();
        }

        QStringList items;
        for (int i = 0; i < pCom->count(); ++i)
        {
            items << pCom->itemText(i);
        }

        bool bMa = false; // 是否匹配
        for (auto b : items)
        {
            if (b == strName)
            {
                bMa = true;
                break;
            }
        }

        if (!bMa)
        {
            pCom->addItem(strName);
        }
    }

    AdjustComboBoxWidth(pCom);
    pCom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
}

void LightJoystickSwitchPage::BondSliderAndLineEdit(QSlider* slider, QLineEdit* lineEdit)
{
    QIntValidator* validator = new QIntValidator(slider->minimum(), slider->maximum(), lineEdit);
    lineEdit->setValidator(validator);

    connect(slider, &QSlider::valueChanged, [lineEdit](int value) {
        lineEdit->setText(QString::number(value));
    });

    connect(lineEdit, &QLineEdit::textChanged, [&, slider, lineEdit](const QString& text)
        {
            bool ok;
            int value = text.toInt(&ok);
            if (ok && value >= slider->minimum() && value <= slider->maximum())
            {
                slider->setValue(value);
            }
            else if (!text.isEmpty())
            {
                int closestValue = qMin(qMax(text.toInt(&ok), slider->minimum()), slider->maximum());
                slider->setValue(closestValue);
            }

            if (m_pPageSwitchGroup)
            {
                // 执行匹配灯光
                int niD = m_pPageSwitchGroup->m_cameaInfo.iCameraId;
                //if (niD == 1)
                {
                    // 相机窗口
                    if (m_pCameraBind)
                    {
                        m_pCameraBind->JSetRedLight(niD, MatchSelectedLightIndex(lineEdit), value);
                    }
                }
            }
        });
}

void LightJoystickSwitchPage::setLigthValue(int redLight,int greenLight,int blueLight,int dotLight)
{
    setLightWidget(redLight, ui->RedLight, ui->RedLightlineEdit, ui->RedLightverticalSlider, ui->RedLightprogressBar, ui->RedLightlabel);
    setLightWidget(greenLight, ui->GreenLight, ui->GreenLightlineEdit, ui->GreenLightverticalSlider, ui->GreenLightprogressBar, ui->GreenLightlabel);
    setLightWidget(blueLight, ui->BlueLight, ui->BlueLightlineEdit, ui->BlueLightverticalSlider, ui->BlueLightprogressBar, ui->BlueLightlabel);
    setLightWidget(dotLight, ui->DotLight, ui->DotLightlineEdit, ui->DotLightverticalSlider, ui->DotLightprogressBar, ui->DotLightlabel);
}

void LightJoystickSwitchPage::setLightWidget(int value, QWidget *lightWidget, QLineEdit *lineEdit, QSlider *slider, QProgressBar *progressBar, QLabel *label) 
{
    if (0 <= value && value <= 100)
    {
        lightWidget->show();
        lineEdit->show();
        slider->show();
        progressBar->show();
        label->show();
        lineEdit->setText(QString::number(value));
        progressBar->setValue(value);
        slider->setValue(value);
    } 
    else if (value == -1) 
    {
        lightWidget->hide();
        lineEdit->hide();
        slider->hide();
        progressBar->hide();
        label->hide();
    }
}


void LightJoystickSwitchPage::on_move_Button_clicked()
{
    RunMoveOrMoveTo(false);
}


void LightJoystickSwitchPage::on_moveTo_Button_clicked()
{
    RunMoveOrMoveTo(true);
}


void LightJoystickSwitchPage::on_left_Button_clicked()
{
    m_moveAxisInfo.AxisType = "X";
    MoveJoystick();
}


void LightJoystickSwitchPage::on_up_Button_clicked()
{
    m_moveAxisInfo.AxisType = "Y";
    MoveJoystick();
}


void LightJoystickSwitchPage::on_right_Button_clicked()
{
    m_moveAxisInfo.AxisType = "X";
    MoveJoystick();
}


void LightJoystickSwitchPage::on_down_Button_clicked()
{
    m_moveAxisInfo.AxisType = "Y";
    MoveJoystick();
}

void LightJoystickSwitchPage::GetModuleTypeSlots(const ST_MOVE_AXIS& _module)
{
    if (!_module.isNoNull)
    {
        int newIndex = (ui->switchTabWidget->currentIndex() + 1) % ui->switchTabWidget->count();
        ui->switchTabWidget->setCurrentIndex(newIndex);
    }


    /*m_isSlots = true;
    SetMoveJoystickInfo(_module);*/
}

void LightJoystickSwitchPage::InitMainCameraBind(CameraBind* pCameraBind, bool bUpdate /*= true*/)
{
    m_pCameraBind = pCameraBind;
    if (bUpdate)
    {
        UpdataLightVal();
    }
    if (m_pCameraBind)
    {
        DeduplicationBox(ui->modeComboBox, m_pCameraBind->m_vecCAxis, 0);
    }
}

void LightJoystickSwitchPage::UpdatemPageGroup(Group* pGroup)
{
    m_pPageSwitchGroup = pGroup;
}

void LightJoystickSwitchPage::SwitchJoystickPage(bool bSwitch)
{
    ResetIdleTimer(bSwitch);
    //int newIndex = (ui->switchTabWidget->currentIndex() + 1) % ui->switchTabWidget->count();
    if (m_isSlots)
    {
        ui->switchTabWidget->setCurrentIndex(1);
    }
    else
    {
        ui->switchTabWidget->setCurrentIndex(0);
    }
    
    m_isSlots = false;
}

void LightJoystickSwitchPage::HideOrShowPage(bool isHide)
{
    ui->switchTabWidget->setVisible(isHide);
}

void LightJoystickSwitchPage::SetMoveJoystickInfo(const ST_MOVE_AXIS& movInfo)
{
    //m_moveAxisInfo.ModuleType   = movInfo.ModuleType;
    //m_moveAxisInfo.AxisType     = movInfo.AxisType;
    //m_moveAxisInfo.pos          = movInfo.pos; // 这个距离可能会变动// 根据摇杆区分等级
    m_moveAxisInfo = movInfo;

    if (m_moveAxisInfo.isSwitch)
    {
        // 点击摇杆的时候开启定时器，然后3秒关闭
        SwitchJoystickPage(true);
    }
 
}

void LightJoystickSwitchPage::timerEvent(QTimerEvent* event)
{
    int nID = event->timerId();
    if (m_nTimeShowPos == nID)
    {
        RealTimeUpdatesToU();
    }
    else if (m_idleTimer == nID)
    {
        SwitchJoystickPage(false);
    }
    else if (m_nUpdateUiAxis == nID)
    {
        UpDataAxisToUi();
    }
}

QString LightJoystickSwitchPage::CombiningStr(bool isUpdate /*= false*/)
{
    double pos = m_moveAxisInfo.pos;
    QString strShow = tr("Currently selected mode:", "当前选中模式:");
    if (isUpdate)
    {
        strShow = tr("Move Pos:","移动点:");
        if (m_pCameraBind)
        {
            m_pCameraBind->YGetAxisPosition(m_moveAxisInfo.ModuleType, m_moveAxisInfo.AxisType, pos);
        }
    }

    strShow += m_moveAxisInfo.ModuleType.c_str();
    strShow += " ";
    strShow += m_moveAxisInfo.AxisType.c_str();
    strShow += " ";
    strShow += QString::number(pos, 'f', 2);

    return strShow;
}

void LightJoystickSwitchPage::RealTimeUpdatesToU()
{
    if (m_pCameraBind)
    {
       // ui->JTabShowLableLoop->setText(CombiningStr(true));
    }
}

void LightJoystickSwitchPage::ResetIdleTimer(bool bStart /*= false*/)
{
    if (bStart)
    {
        if (m_idleTimer != -1)
        {
            // 计时器没关，关闭重新打开
            ResetIdleTimer(false);
            ResetIdleTimer(true);
        }

        if (isActiveWindow())
        {
            m_idleTimer = startTimer(g_unnSuspensionWaitingTime);
        }
    }
    else
    {
        killTimer(m_idleTimer);
        m_idleTimer = -1;
    }
}

void LightJoystickSwitchPage::MoveJoystick()
{
    if (m_pCameraBind)
    {
        m_pCameraBind->YGetAxisPosition(m_moveAxisInfo.ModuleType, m_moveAxisInfo.AxisType, m_moveAxisInfo.pos);
    }
}

void LightJoystickSwitchPage::RunMoveOrMoveTo(bool isMoveTo)
{
    QString strErrInfo = {};
    QString strNum = "1";//ui->valLineEdit->text().trimmed();
    if (strNum.isEmpty())
    {
        strErrInfo = tr("please input value","请输入值");
    }
    else
    {
        double doNum = strNum.toDouble();

        if (m_moveAxisInfo.ModuleType != "")
        {
            if (m_moveAxisInfo.AxisType != "")
            {
                m_pCameraBind->SetModuleMove(m_moveAxisInfo.ModuleType, m_moveAxisInfo.AxisType, doNum, isMoveTo);
            }
            else
            {
                strErrInfo = tr("AxisType is Empty", "AxisType 为空");
            }
        }
        else
        {
            strErrInfo = tr("ModuleType is Empty", "ModuleType 为空");
        }
    }

    if (!strErrInfo.isEmpty())
    {
        JMessageTip::Message_question(strErrInfo);
    }
}

void LightJoystickSwitchPage::UpdataLightVal()
{
    if (m_pCameraBind->m_pCViewInterface == nullptr)
    {
        return;
    }

    if (m_pPageSwitchGroup)
    {
        int niD = m_pPageSwitchGroup->m_cameaInfo.iCameraId;
        //if (niD == 1)
        {
            // 切换灯光
            ST_LIGHT_VAL _val = m_pCameraBind->JGetLight(niD);
            setLigthValue(_val.redLightValue, _val.greenLightValue, _val.blueLightValue, _val.pointLightValue);
        }
    }
}

EN_LIGHT_INDEX LightJoystickSwitchPage::MatchSelectedLightIndex(QLineEdit* lineEdit)
{
    EN_LIGHT_INDEX nIndex = EN_LIGHT_INDEX::Red;
    if (lineEdit == ui->RedLightlineEdit)
    {
        nIndex = EN_LIGHT_INDEX::Red;
    }
    else if (lineEdit == ui->GreenLightlineEdit)
    {
        nIndex = EN_LIGHT_INDEX::Green;
    }
    else if (lineEdit == ui->BlueLightlineEdit)
    {
        nIndex = EN_LIGHT_INDEX::Blue;
    }
    else if (lineEdit == ui->DotLightlineEdit)
    {
        nIndex = EN_LIGHT_INDEX::Point;
    }

    return nIndex;
}

void LightJoystickSwitchPage::resizeSingleUI() {
    
    ui->switchTabWidget->setGeometry(QRect(0, 0, 265, 240));
 
    ui->GreenLightTab->setGeometry(QRect(0, 0, 60, 32));
    ui->JoystickTab->setGeometry(QRect(0, 0, 259, 215));
    
    
    ui->RedLight->setGeometry(QRect(0, 0, 61, 114));
    ui->RedLightlineEdit->setGeometry(QRect(10, 78, 40, 24));
    ui->RedLightprogressBar->setGeometry(QRect(32, 15, 18, 51));
    ui->RedLightverticalSlider->setGeometry(QRect(10, 12, 18, 56));
    ui->RedLightlabel->setGeometry(QRect(39, 22, 10, 34));

    ui->GreenLight->setGeometry(QRect(70, 0, 61, 114));
    ui->GreenLightlineEdit->setGeometry(QRect(10, 78, 40, 24));
    ui->GreenLightprogressBar->setGeometry(QRect(32, 15, 18, 51));
    ui->GreenLightverticalSlider->setGeometry(QRect(10, 12, 18, 56));
    ui->GreenLightlabel->setGeometry(QRect(36, 22, 10, 34));

    ui->BlueLight->setGeometry(QRect(140, 0, 61, 114));
    ui->BlueLightlineEdit->setGeometry(QRect(10, 78, 40, 24));
    ui->BlueLightprogressBar->setGeometry(QRect(32, 15, 18, 51));
    ui->BlueLightverticalSlider->setGeometry(QRect(10, 12, 18, 56));
    ui->BlueLightlabel->setGeometry(QRect(32, 22, 19, 34));

    ui->DotLight->setGeometry(QRect(200, 0, 61, 114));
    ui->DotLightlineEdit->setGeometry(QRect(10, 78, 40, 24));
    ui->DotLightprogressBar->setGeometry(QRect(32, 15, 18, 51));
    ui->DotLightverticalSlider->setGeometry(QRect(10, 12, 18, 56));
    ui->DotLightlabel->setGeometry(QRect(32, 22, 19, 34));

    ui->groupBox_2->setGeometry(QRect(0, 0, 250, 131));
    ui->xCheckBox->setGeometry(QRect(0, 0, 30, 30));
    ui->xLineEdit->setGeometry(QRect(31, 0, 50, 30));

    ui->rCheckBox->setGeometry(QRect(0, 0, 30, 30));
    ui->rLineEdit->setGeometry(QRect(31, 0, 50, 30));

    ui->xLayout->setGeometry(QRect(30, 0, 90, 30));
    ui->groupBox->setGeometry(QRect(0, 100, 141, 111));
    ui->left_Button->setGeometry(QRect(10, 40, 41, 31));
    ui->right_Button->setGeometry(QRect(90, 40, 41, 31));
    ui->up_Button->setGeometry(QRect(50, 10, 41, 31));
    ui->down_Button->setGeometry(QRect(50, 70, 41, 31));


}


void LightJoystickSwitchPage::on_xLineEdit_textChanged(const QString &arg1)
{
    MoveModule("X", arg1);
}


void LightJoystickSwitchPage::on_yLineEdit_textChanged(const QString &arg1)
{
    MoveModule("Y", arg1);
}


void LightJoystickSwitchPage::on_zLineEdit_textChanged(const QString &arg1)
{
    MoveModule("Z", arg1);
}


void LightJoystickSwitchPage::on_rLineEdit_textChanged(const QString &arg1)
{
    MoveModule("R", arg1);
}


void LightJoystickSwitchPage::on_forceLineEdit_textChanged(const QString &arg1)
{
    MoveModule("FORCE", arg1);
}

void LightJoystickSwitchPage::on_modeComboBox_currentIndexChanged(int index)
{
    QString strMod = ui->modeComboBox->itemText(index);
    // 先禁用所有相关布局
    const QList<QLayout*> allLayouts = {
        ui->forceLayout,
        ui->xLayout,
        ui->yLayout,
        ui->rLayout,
        ui->zLayout,
    };
    for (auto* layout : allLayouts) 
    {
        DisableLayoutWidgets(layout, false);
    }

    // 收集当前模块支持的轴类型
    QSet<QString> supportedAxes;
    for (const auto& axis : m_pCameraBind->m_vecCAxis) 
    {
        if (strMod == axis->GetModuleType().c_str())
        {
            supportedAxes.insert(axis->GetStringAxisType().c_str());
        }
    }

    // 根据支持的轴启用对应布局
    const QHash<QString, QLayout*> axisToLayout = {
        {"FORCE", ui->forceLayout},
        {"X", ui->xLayout},
        {"Y", ui->yLayout},
        {"R", ui->rLayout},
        {"Z", ui->zLayout},
        {"Z1", ui->zLayout}
    };


    for (auto it = axisToLayout.constBegin(); it != axisToLayout.constEnd(); ++it) 
    {
        if (supportedAxes.contains(it.key())) 
        {
            m_listCurrentShowAxis.push_back(it.key());
            DisableLayoutWidgets(it.value(), true);
        }
    }   

    m_moveAxisInfo.ModuleType = ui->modeComboBox->currentText().toStdString();
}