#include "dialogalgoarg.h"
#include "ui_dialogalgoarg.h"

#include <QCheckBox>
#include <QDateTime>
#include <QDoubleValidator>
#include <QFormLayout>
#include <QFont>
#include <QIntValidator>
#include <QLineEdit>
#include <QList>
#include <QPushButton>
#include <QScrollArea>
#include <QTabWidget>
#include <QVBoxLayout>

#include "ParkingSpaceGuidePresenter.h"
#include "PathManager.h"
#include "StyledMessageBox.h"

DialogAlgoArg::DialogAlgoArg(QWidget* parent)
    : QDialog(parent)
    , ui(new Ui::DialogAlgoArg)
{
    ui->setupUi(this);
    setWindowTitle(QStringLiteral("停车引导参数设置"));
    if (ui->label_title) {
        ui->label_title->setText(QStringLiteral("停车引导参数设置"));
    }
    BuildUi();
    connect(ui->tabWidget, &QTabWidget::currentChanged, this, [this](int index) {
        if (index >= 0 && index < m_visiblePages.size()) {
            UpdateTitle(m_visiblePages[index]);
        }
    });
    ApplyUiFont();
}

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

void DialogAlgoArg::SetPresenter(ParkingSpaceGuidePresenter* presenter)
{
    m_presenter = presenter;
    LoadParams();
}

void DialogAlgoArg::SetCurrentPage(ConfigPage page)
{
    if (!ui || !ui->tabWidget) {
        return;
    }

    ShowTabGroup(page);
}

void DialogAlgoArg::ShowTabGroup(ConfigPage page)
{
    if (!ui || !ui->tabWidget) {
        return;
    }

    const bool oldBlocked = ui->tabWidget->blockSignals(true);
    ui->tabWidget->clear();
    HideDetachedTabs();
    m_visiblePages.clear();

    auto addTab = [this](QWidget* tab, const QString& title, ConfigPage tabPage) {
        if (!tab) {
            return;
        }
        ui->tabWidget->addTab(tab, title);
        m_visiblePages.push_back(tabPage);
    };

    int selectedIndex = 0;
    if (page == ConfigPage::Camera || page == ConfigPage::Lidar) {
        addTab(m_cameraTab, QStringLiteral("相机参数"), ConfigPage::Camera);
        addTab(m_lidarTab, QStringLiteral("雷达参数"), ConfigPage::Lidar);
        selectedIndex = page == ConfigPage::Lidar ? 1 : 0;
    } else if (page == ConfigPage::Calibration) {
        addTab(m_centerLineTab, QStringLiteral("中心线标定"), ConfigPage::Calibration);
        addTab(m_stopLineTab, QStringLiteral("停机线标定"), ConfigPage::Calibration);
    } else {
        addTab(m_detectionTab, QStringLiteral("检测参数"), ConfigPage::Detection);
        addTab(m_multicastTab, QStringLiteral("组播参数"), ConfigPage::Multicast);
        selectedIndex = page == ConfigPage::Multicast ? 1 : 0;
    }

    if (selectedIndex >= 0 && selectedIndex < ui->tabWidget->count()) {
        ui->tabWidget->setCurrentIndex(selectedIndex);
    }
    if (ui->tabWidget->currentWidget()) {
        ui->tabWidget->currentWidget()->show();
    }
    ui->tabWidget->blockSignals(oldBlocked);
    UpdateTitle(page);
}

void DialogAlgoArg::UpdateTitle(ConfigPage page)
{
    QString title = QStringLiteral("停车引导参数设置");
    switch (page) {
    case ConfigPage::Detection:
        title = QStringLiteral("检测参数设置");
        break;
    case ConfigPage::Camera:
        title = QStringLiteral("相机参数设置");
        break;
    case ConfigPage::Lidar:
        title = QStringLiteral("雷达参数设置");
        break;
    case ConfigPage::Multicast:
        title = QStringLiteral("组播参数设置");
        break;
    case ConfigPage::Calibration:
        title = QStringLiteral("相机调平标定");
        break;
    }

    setWindowTitle(title);
    if (ui && ui->label_title) {
        ui->label_title->setText(title);
    }
}

void DialogAlgoArg::HideDetachedTabs()
{
    const QList<QWidget*> tabs = {
        m_detectionTab,
        m_cameraTab,
        m_lidarTab,
        m_multicastTab,
        m_centerLineTab,
        m_stopLineTab
    };

    for (QWidget* tab : tabs) {
        if (tab && tab->parentWidget() != ui->tabWidget->currentWidget()) {
            tab->hide();
        }
    }
}

void DialogAlgoArg::BuildUi()
{
    ui->tabWidget->clear();

    auto makeTab = [this](QWidget** tabWidget, const QString& title) -> QWidget* {
        auto* scroll = new QScrollArea(ui->tabWidget);
        scroll->setWidgetResizable(true);
        auto* page = new QWidget(scroll);
        page->setObjectName(title);
        auto* layout = new QFormLayout(page);
        layout->setContentsMargins(24, 24, 24, 24);
        layout->setSpacing(14);
        page->setLayout(layout);
        scroll->setWidget(page);
        if (tabWidget) {
            *tabWidget = scroll;
        }
        scroll->hide();
        return page;
    };

    QWidget* algo = makeTab(&m_detectionTab, QStringLiteral("检测参数"));
    m_minGuideDistance = AddDoubleEditor(algo, QStringLiteral("最小引导距离(毫米)"), 0, 0.0, 100000.0);
    m_maxGuideDistance = AddDoubleEditor(algo, QStringLiteral("最大引导距离(毫米)"), 1, 0.0, 100000.0);
    m_targetStopOffset = AddDoubleEditor(algo, QStringLiteral("目标停止偏移(毫米)"), 2, -100000.0, 100000.0);
    m_lateralTolerance = AddDoubleEditor(algo, QStringLiteral("横向容差(毫米)"), 3, 0.0, 100000.0);
    m_angleTolerance = AddDoubleEditor(algo, QStringLiteral("角度容差(度)"), 4, 0.0, 180.0);
    m_confidenceThreshold = AddDoubleEditor(algo, QStringLiteral("置信度阈值"), 5, 0.0, 1.0);

    QWidget* camera = makeTab(&m_cameraTab, QStringLiteral("相机参数"));
    m_mvsSerialNumber = AddTextEditor(camera, QStringLiteral("设备序列号"), 0);
    m_mvsDeviceIndex = AddIntEditor(camera, QStringLiteral("设备序号"), 1, 0, 64);
    m_mvsEnabled = AddCheckBox(camera, QStringLiteral("启用"), 2);

    QWidget* lidar = makeTab(&m_lidarTab, QStringLiteral("雷达参数"));
    m_lidarType = AddTextEditor(lidar, QStringLiteral("雷达型号"), 0);
    m_lidarHost = AddTextEditor(lidar, QStringLiteral("监听地址"), 1);
    m_lidarMsopPort = AddIntEditor(lidar, QStringLiteral("数据端口"), 2, 1, 65535);
    m_lidarDifopPort = AddIntEditor(lidar, QStringLiteral("设备端口"), 3, 1, 65535);
    m_lidarMinDistance = AddDoubleEditor(lidar, QStringLiteral("最小距离(米)"), 4, 0.0, 1000.0);
    m_lidarMaxDistance = AddDoubleEditor(lidar, QStringLiteral("最大距离(米)"), 5, 0.0, 1000.0);
    m_lidarStartAngle = AddDoubleEditor(lidar, QStringLiteral("起始角度(度)"), 6, 0.0, 360.0);
    m_lidarEndAngle = AddDoubleEditor(lidar, QStringLiteral("结束角度(度)"), 7, 0.0, 360.0);

    QWidget* udp = makeTab(&m_multicastTab, QStringLiteral("组播参数"));
    m_udpAddress = AddTextEditor(udp, QStringLiteral("组播地址"), 0);
    m_udpPort = AddIntEditor(udp, QStringLiteral("组播端口"), 1, 1, 65535);
    m_udpTargetId = AddTextEditor(udp, QStringLiteral("目标编号"), 2);
    m_udpParkId = AddTextEditor(udp, QStringLiteral("车位编号"), 3);
    m_udpEnabled = AddCheckBox(udp, QStringLiteral("启用"), 4);

    QWidget* centerLine = makeTab(&m_centerLineTab, QStringLiteral("中心线标定"));
    m_centerLineCalibrated = AddCheckBox(centerLine, QStringLiteral("已标定"), 0);
    m_centerLineStartX = AddDoubleEditor(centerLine, QStringLiteral("起点X"), 1, -1000000.0, 1000000.0);
    m_centerLineStartY = AddDoubleEditor(centerLine, QStringLiteral("起点Y"), 2, -1000000.0, 1000000.0);
    m_centerLineEndX = AddDoubleEditor(centerLine, QStringLiteral("终点X"), 3, -1000000.0, 1000000.0);
    m_centerLineEndY = AddDoubleEditor(centerLine, QStringLiteral("终点Y"), 4, -1000000.0, 1000000.0);
    m_centerLineTime = AddTextEditor(centerLine, QStringLiteral("标定时间"), 5);
    m_centerLineTime->setReadOnly(true);
    m_calibrateCenterLine = AddActionButton(centerLine, QStringLiteral("标定中心线"), 6);
    connect(m_calibrateCenterLine, &QPushButton::clicked,
            this, &DialogAlgoArg::onCalibrateCenterLineClicked);

    QWidget* stopLine = makeTab(&m_stopLineTab, QStringLiteral("停机线标定"));
    m_stopLineCalibrated = AddCheckBox(stopLine, QStringLiteral("已标定"), 0);
    m_stopLineStartX = AddDoubleEditor(stopLine, QStringLiteral("起点X"), 1, -1000000.0, 1000000.0);
    m_stopLineStartY = AddDoubleEditor(stopLine, QStringLiteral("起点Y"), 2, -1000000.0, 1000000.0);
    m_stopLineEndX = AddDoubleEditor(stopLine, QStringLiteral("终点X"), 3, -1000000.0, 1000000.0);
    m_stopLineEndY = AddDoubleEditor(stopLine, QStringLiteral("终点Y"), 4, -1000000.0, 1000000.0);
    m_countdownStartDistance = AddDoubleEditor(stopLine, QStringLiteral("倒计时开始距离(毫米)"), 5, 0.0, 1000000.0);
    m_modelVerifyDistance = AddDoubleEditor(stopLine, QStringLiteral("机型验证距离(毫米)"), 6, 0.0, 1000000.0);
    m_stopLineTime = AddTextEditor(stopLine, QStringLiteral("标定时间"), 7);
    m_stopLineTime->setReadOnly(true);
    m_calibrateStopLine = AddActionButton(stopLine, QStringLiteral("标定停机线"), 8);
    connect(m_calibrateStopLine, &QPushButton::clicked,
            this, &DialogAlgoArg::onCalibrateStopLineClicked);

    ShowTabGroup(ConfigPage::Detection);
}

void DialogAlgoArg::ApplyUiFont()
{
    QFont font;
    font.setPointSize(16);
    setFont(font);

    const QList<QWidget*> widgets = findChildren<QWidget*>();
    for (QWidget* widget : widgets) {
        widget->setFont(font);
    }
}

QLineEdit* DialogAlgoArg::AddDoubleEditor(QWidget* parent, const QString& label, int row, double min, double max)
{
    Q_UNUSED(row);
    auto* edit = new QLineEdit(parent);
    auto* validator = new QDoubleValidator(min, max, 6, edit);
    validator->setNotation(QDoubleValidator::StandardNotation);
    edit->setValidator(validator);
    static_cast<QFormLayout*>(parent->layout())->addRow(label, edit);
    return edit;
}

QLineEdit* DialogAlgoArg::AddIntEditor(QWidget* parent, const QString& label, int row, int min, int max)
{
    Q_UNUSED(row);
    auto* edit = new QLineEdit(parent);
    edit->setValidator(new QIntValidator(min, max, edit));
    static_cast<QFormLayout*>(parent->layout())->addRow(label, edit);
    return edit;
}

QLineEdit* DialogAlgoArg::AddTextEditor(QWidget* parent, const QString& label, int row, bool password)
{
    Q_UNUSED(row);
    auto* edit = new QLineEdit(parent);
    if (password) {
        edit->setEchoMode(QLineEdit::Password);
    }
    static_cast<QFormLayout*>(parent->layout())->addRow(label, edit);
    return edit;
}

QCheckBox* DialogAlgoArg::AddCheckBox(QWidget* parent, const QString& label, int row)
{
    Q_UNUSED(row);
    auto* check = new QCheckBox(parent);
    static_cast<QFormLayout*>(parent->layout())->addRow(label, check);
    return check;
}

QPushButton* DialogAlgoArg::AddActionButton(QWidget* parent, const QString& text, int row)
{
    Q_UNUSED(row);
    auto* button = new QPushButton(text, parent);
    button->setMinimumHeight(40);
    button->setStyleSheet(
        "QPushButton {"
        "background-color: rgb(60, 120, 180);"
        "color: rgb(221, 225, 233);"
        "border: none;"
        "border-radius: 4px;"
        "padding: 8px;"
        "}"
        "QPushButton:hover { background-color: rgb(80, 140, 200); }"
        "QPushButton:pressed { background-color: rgb(40, 100, 160); }");
    static_cast<QFormLayout*>(parent->layout())->addRow(QString(), button);
    return button;
}

void DialogAlgoArg::LoadParams()
{
    if (!m_presenter || !m_presenter->GetConfigManager()) {
        return;
    }

    const ConfigResult config = m_presenter->GetConfigManager()->GetConfigResult();
    const VrParkingSpaceGuideParam& p = config.algorithmParams.guideParam;

    SetDouble(m_minGuideDistance, p.minGuideDistance);
    SetDouble(m_maxGuideDistance, p.maxGuideDistance);
    SetDouble(m_targetStopOffset, p.targetStopOffset);
    SetDouble(m_lateralTolerance, p.lateralTolerance);
    SetDouble(m_angleTolerance, p.angleTolerance);
    SetDouble(m_confidenceThreshold, p.confidenceThreshold);

    m_mvsSerialNumber->setText(QString::fromStdString(config.mvsCamera.serialNumber));
    SetInt(m_mvsDeviceIndex, config.mvsCamera.deviceIndex);
    m_mvsEnabled->setChecked(config.mvsCamera.enabled);

    m_lidarType->setText(QString::fromStdString(config.lidarConfig.lidarType));
    m_lidarHost->setText(QString::fromStdString(config.lidarConfig.hostAddress));
    SetInt(m_lidarMsopPort, config.lidarConfig.msopPort);
    SetInt(m_lidarDifopPort, config.lidarConfig.difopPort);
    SetDouble(m_lidarMinDistance, config.lidarConfig.minDistance);
    SetDouble(m_lidarMaxDistance, config.lidarConfig.maxDistance);
    SetDouble(m_lidarStartAngle, config.lidarConfig.startAngle);
    SetDouble(m_lidarEndAngle, config.lidarConfig.endAngle);

    m_udpAddress->setText(QString::fromStdString(config.udpBroadcastConfig.address));
    SetInt(m_udpPort, config.udpBroadcastConfig.port);
    m_udpTargetId->setText(QString::fromStdString(config.udpBroadcastConfig.targetId));
    m_udpParkId->setText(QString::fromStdString(config.udpBroadcastConfig.parkId));
    m_udpEnabled->setChecked(config.udpBroadcastConfig.enabled);

    const VrParkingSpaceCalibrationParam& calibration = config.algorithmParams.calibrationParam;
    SetLineCalibration(m_centerLineCalibrated,
                       m_centerLineStartX,
                       m_centerLineStartY,
                       m_centerLineEndX,
                       m_centerLineEndY,
                       m_centerLineTime,
                       calibration.centerLine);
    SetLineCalibration(m_stopLineCalibrated,
                       m_stopLineStartX,
                       m_stopLineStartY,
                       m_stopLineEndX,
                       m_stopLineEndY,
                       m_stopLineTime,
                       calibration.stopLine);
    SetDouble(m_countdownStartDistance, calibration.countdownStartDistance);
    SetDouble(m_modelVerifyDistance, calibration.modelVerifyDistance);
}

bool DialogAlgoArg::SaveParams()
{
    if (!m_presenter || !m_presenter->GetConfigManager()) {
        return false;
    }

    SystemConfig systemConfig = m_presenter->GetConfigManager()->GetConfig();
    ConfigResult& config = systemConfig.configResult;
    VrParkingSpaceGuideParam& p = config.algorithmParams.guideParam;

    if (!GetDouble(m_minGuideDistance, QStringLiteral("最小引导距离"), p.minGuideDistance)) return false;
    if (!GetDouble(m_maxGuideDistance, QStringLiteral("最大引导距离"), p.maxGuideDistance)) return false;
    if (!GetDouble(m_targetStopOffset, QStringLiteral("目标停止偏移"), p.targetStopOffset)) return false;
    if (!GetDouble(m_lateralTolerance, QStringLiteral("横向容差"), p.lateralTolerance)) return false;
    if (!GetDouble(m_angleTolerance, QStringLiteral("角度容差"), p.angleTolerance)) return false;
    if (!GetDouble(m_confidenceThreshold, QStringLiteral("置信度阈值"), p.confidenceThreshold)) return false;

    config.mvsCamera.serialNumber = m_mvsSerialNumber->text().trimmed().toStdString();
    if (!GetInt(m_mvsDeviceIndex, QStringLiteral("相机设备序号"), config.mvsCamera.deviceIndex)) return false;
    config.mvsCamera.enabled = m_mvsEnabled->isChecked();

    config.lidarConfig.lidarType = m_lidarType->text().trimmed().toStdString();
    config.lidarConfig.hostAddress = m_lidarHost->text().trimmed().toStdString();
    int intValue = 0;
    if (!GetInt(m_lidarMsopPort, QStringLiteral("雷达数据端口"), intValue)) return false;
    config.lidarConfig.msopPort = static_cast<unsigned short>(intValue);
    if (!GetInt(m_lidarDifopPort, QStringLiteral("雷达设备端口"), intValue)) return false;
    config.lidarConfig.difopPort = static_cast<unsigned short>(intValue);
    if (!GetFloat(m_lidarMinDistance, QStringLiteral("雷达最小距离"), config.lidarConfig.minDistance)) return false;
    if (!GetFloat(m_lidarMaxDistance, QStringLiteral("雷达最大距离"), config.lidarConfig.maxDistance)) return false;
    if (!GetFloat(m_lidarStartAngle, QStringLiteral("雷达起始角度"), config.lidarConfig.startAngle)) return false;
    if (!GetFloat(m_lidarEndAngle, QStringLiteral("雷达结束角度"), config.lidarConfig.endAngle)) return false;

    config.udpBroadcastConfig.address = m_udpAddress->text().trimmed().toStdString();
    if (!GetInt(m_udpPort, QStringLiteral("组播端口"), config.udpBroadcastConfig.port)) return false;
    config.udpBroadcastConfig.targetId = m_udpTargetId->text().trimmed().toStdString();
    config.udpBroadcastConfig.parkId = m_udpParkId->text().trimmed().toStdString();
    config.udpBroadcastConfig.enabled = m_udpEnabled->isChecked();

    VrParkingSpaceCalibrationParam& calibration = config.algorithmParams.calibrationParam;
    if (!GetLineCalibration(m_centerLineCalibrated,
                            m_centerLineStartX,
                            m_centerLineStartY,
                            m_centerLineEndX,
                            m_centerLineEndY,
                            m_centerLineTime,
                            QStringLiteral("中心线"),
                            calibration.centerLine)) return false;
    if (!GetLineCalibration(m_stopLineCalibrated,
                            m_stopLineStartX,
                            m_stopLineStartY,
                            m_stopLineEndX,
                            m_stopLineEndY,
                            m_stopLineTime,
                            QStringLiteral("停机线"),
                            calibration.stopLine)) return false;
    if (!GetDouble(m_countdownStartDistance, QStringLiteral("倒计时开始距离"), calibration.countdownStartDistance)) return false;
    if (!GetDouble(m_modelVerifyDistance, QStringLiteral("机型验证距离"), calibration.modelVerifyDistance)) return false;

    config.Normalize();

    if (!m_presenter->GetConfigManager()->UpdateFullConfig(systemConfig)) {
        StyledMessageBox::warning(this, QStringLiteral("失败"), QStringLiteral("更新配置缓存失败"));
        return false;
    }

    const QString configPath = PathManager::GetInstance().GetConfigFilePath();
    if (!m_presenter->GetConfigManager()->SaveConfigToFile(configPath.toStdString())) {
        StyledMessageBox::warning(this, QStringLiteral("失败"), QStringLiteral("保存配置文件失败"));
        return false;
    }

    m_presenter->OnConfigChanged(config);
    return true;
}

void DialogAlgoArg::ResetParams()
{
    ConfigResult config;
    config.Normalize();
    const VrParkingSpaceGuideParam& p = config.algorithmParams.guideParam;
    SetDouble(m_minGuideDistance, p.minGuideDistance);
    SetDouble(m_maxGuideDistance, p.maxGuideDistance);
    SetDouble(m_targetStopOffset, p.targetStopOffset);
    SetDouble(m_lateralTolerance, p.lateralTolerance);
    SetDouble(m_angleTolerance, p.angleTolerance);
    SetDouble(m_confidenceThreshold, p.confidenceThreshold);

    m_mvsSerialNumber->setText(QString::fromStdString(config.mvsCamera.serialNumber));
    SetInt(m_mvsDeviceIndex, config.mvsCamera.deviceIndex);
    m_mvsEnabled->setChecked(config.mvsCamera.enabled);

    m_lidarType->setText(QString::fromStdString(config.lidarConfig.lidarType));
    m_lidarHost->setText(QString::fromStdString(config.lidarConfig.hostAddress));
    SetInt(m_lidarMsopPort, config.lidarConfig.msopPort);
    SetInt(m_lidarDifopPort, config.lidarConfig.difopPort);
    SetDouble(m_lidarMinDistance, config.lidarConfig.minDistance);
    SetDouble(m_lidarMaxDistance, config.lidarConfig.maxDistance);
    SetDouble(m_lidarStartAngle, config.lidarConfig.startAngle);
    SetDouble(m_lidarEndAngle, config.lidarConfig.endAngle);

    m_udpAddress->setText(QString::fromStdString(config.udpBroadcastConfig.address));
    SetInt(m_udpPort, config.udpBroadcastConfig.port);
    m_udpTargetId->setText(QString::fromStdString(config.udpBroadcastConfig.targetId));
    m_udpParkId->setText(QString::fromStdString(config.udpBroadcastConfig.parkId));
    m_udpEnabled->setChecked(config.udpBroadcastConfig.enabled);

    const VrParkingSpaceCalibrationParam& calibration = config.algorithmParams.calibrationParam;
    SetLineCalibration(m_centerLineCalibrated,
                       m_centerLineStartX,
                       m_centerLineStartY,
                       m_centerLineEndX,
                       m_centerLineEndY,
                       m_centerLineTime,
                       calibration.centerLine);
    SetLineCalibration(m_stopLineCalibrated,
                       m_stopLineStartX,
                       m_stopLineStartY,
                       m_stopLineEndX,
                       m_stopLineEndY,
                       m_stopLineTime,
                       calibration.stopLine);
    SetDouble(m_countdownStartDistance, calibration.countdownStartDistance);
    SetDouble(m_modelVerifyDistance, calibration.modelVerifyDistance);
}

void DialogAlgoArg::SetDouble(QLineEdit* edit, double value)
{
    if (edit) {
        edit->setText(QString::number(value, 'g', 12));
    }
}

void DialogAlgoArg::SetInt(QLineEdit* edit, int value)
{
    if (edit) {
        edit->setText(QString::number(value));
    }
}

void DialogAlgoArg::SetLineCalibration(QCheckBox* calibrated,
                                       QLineEdit* startX,
                                       QLineEdit* startY,
                                       QLineEdit* endX,
                                       QLineEdit* endY,
                                       QLineEdit* time,
                                       const VrGuideLineCalibration& value)
{
    if (calibrated) {
        calibrated->setChecked(value.calibrated);
    }
    SetDouble(startX, value.startX);
    SetDouble(startY, value.startY);
    SetDouble(endX, value.endX);
    SetDouble(endY, value.endY);
    if (time) {
        time->setText(QString::fromStdString(value.calibrationTime));
    }
}

bool DialogAlgoArg::GetDouble(QLineEdit* edit, const QString& label, double& value)
{
    bool ok = false;
    value = edit->text().trimmed().toDouble(&ok);
    if (!ok) {
        StyledMessageBox::warning(this, QStringLiteral("参数错误"), QStringLiteral("%1无效").arg(label));
        edit->setFocus();
        return false;
    }
    return true;
}

bool DialogAlgoArg::GetFloat(QLineEdit* edit, const QString& label, float& value)
{
    double doubleValue = 0.0;
    if (!GetDouble(edit, label, doubleValue)) {
        return false;
    }
    value = static_cast<float>(doubleValue);
    return true;
}

bool DialogAlgoArg::GetInt(QLineEdit* edit, const QString& label, int& value)
{
    bool ok = false;
    value = edit->text().trimmed().toInt(&ok);
    if (!ok) {
        StyledMessageBox::warning(this, QStringLiteral("参数错误"), QStringLiteral("%1无效").arg(label));
        edit->setFocus();
        return false;
    }
    return true;
}

bool DialogAlgoArg::GetLineCalibration(QCheckBox* calibrated,
                                       QLineEdit* startX,
                                       QLineEdit* startY,
                                       QLineEdit* endX,
                                       QLineEdit* endY,
                                       QLineEdit* time,
                                       const QString& label,
                                       VrGuideLineCalibration& value)
{
    if (!GetDouble(startX, QStringLiteral("%1起点X").arg(label), value.startX)) return false;
    if (!GetDouble(startY, QStringLiteral("%1起点Y").arg(label), value.startY)) return false;
    if (!GetDouble(endX, QStringLiteral("%1终点X").arg(label), value.endX)) return false;
    if (!GetDouble(endY, QStringLiteral("%1终点Y").arg(label), value.endY)) return false;

    value.calibrated = calibrated ? calibrated->isChecked() : false;
    value.calibrationTime = time ? time->text().trimmed().toStdString() : std::string();
    return !value.calibrated || ValidateLineCalibration(value, label);
}

bool DialogAlgoArg::ValidateLineCalibration(const VrGuideLineCalibration& value, const QString& label)
{
    if (value.startX == value.endX && value.startY == value.endY) {
        StyledMessageBox::warning(this,
                                  QStringLiteral("参数错误"),
                                  QStringLiteral("%1起点和终点不能相同").arg(label));
        return false;
    }
    return true;
}

bool DialogAlgoArg::SaveCalibrationWithMessage(const QString& message)
{
    if (SaveParams()) {
        StyledMessageBox::information(this, QStringLiteral("提示"), message);
        return true;
    }
    return false;
}

void DialogAlgoArg::onCalibrateCenterLineClicked()
{
    VrGuideLineCalibration line;
    if (!GetLineCalibration(m_centerLineCalibrated,
                            m_centerLineStartX,
                            m_centerLineStartY,
                            m_centerLineEndX,
                            m_centerLineEndY,
                            m_centerLineTime,
                            QStringLiteral("中心线"),
                            line)) {
        return;
    }

    if (!ValidateLineCalibration(line, QStringLiteral("中心线"))) {
        return;
    }

    if (m_centerLineCalibrated) {
        m_centerLineCalibrated->setChecked(true);
    }
    if (m_centerLineTime) {
        m_centerLineTime->setText(QDateTime::currentDateTime().toString(QStringLiteral("yyyy-MM-dd hh:mm:ss")));
    }
    SaveCalibrationWithMessage(QStringLiteral("中心线标定已保存"));
}

void DialogAlgoArg::onCalibrateStopLineClicked()
{
    if (!m_centerLineCalibrated || !m_centerLineCalibrated->isChecked()) {
        StyledMessageBox::warning(this,
                                  QStringLiteral("提示"),
                                  QStringLiteral("请先完成中心线标定"));
        return;
    }

    VrGuideLineCalibration line;
    if (!GetLineCalibration(m_stopLineCalibrated,
                            m_stopLineStartX,
                            m_stopLineStartY,
                            m_stopLineEndX,
                            m_stopLineEndY,
                            m_stopLineTime,
                            QStringLiteral("停机线"),
                            line)) {
        return;
    }

    if (!ValidateLineCalibration(line, QStringLiteral("停机线"))) {
        return;
    }

    if (m_stopLineCalibrated) {
        m_stopLineCalibrated->setChecked(true);
    }
    if (m_stopLineTime) {
        m_stopLineTime->setText(QDateTime::currentDateTime().toString(QStringLiteral("yyyy-MM-dd hh:mm:ss")));
    }
    SaveCalibrationWithMessage(QStringLiteral("停机线标定已保存"));
}

void DialogAlgoArg::on_btnOK_clicked()
{
    if (SaveParams()) {
        accept();
    }
}

void DialogAlgoArg::on_btnCancel_clicked()
{
    reject();
}

void DialogAlgoArg::on_btnApply_clicked()
{
    if (SaveParams()) {
        StyledMessageBox::information(this, QStringLiteral("提示"), QStringLiteral("参数已应用"));
    }
}

void DialogAlgoArg::on_btnReset_clicked()
{
    ResetParams();
}