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

#include <QCheckBox>
#include <QDoubleValidator>
#include <QFormLayout>
#include <QFont>
#include <QIntValidator>
#include <QLineEdit>
#include <QList>
#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();
    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 {
        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);
    }
    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;
    }

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

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

    auto makeTab = [this](QWidget** tabWidget, const QString& title) -> QWidget* {
        auto* scroll = new QScrollArea(this);
        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;
        }
        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);

    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;
}

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);
}

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();
    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);
}

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));
    }
}

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;
}

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();
}