suyu_two/app/src/ui/main_window.cpp

#include "main_window.h"

#include "hmi_editor_widget.h"
#include "alarm_configuration_dialog.h"
#include "register_comment_dialog.h"
#include "logic_editor_widget.h"
#include "logic_instruction_dialog.h"
#include "plc_connection_dialog.h"
#include "runtime_monitor_widget.h"
#include "toolbar_icon_factory.h"
#include "project_workspace_controller.h"
#include "property_panel_controller.h"
#include "runtime_panel_controller.h"
#include "services/hmi_editor_service.h"
#include "services/hmi_navigation_service.h"
#include "services/hmi_runtime_service.h"
#include "services/alarm_editor_service.h"
#include "services/alarm_service.h"
#include "services/logic_editor_service.h"
#include "services/project_service.h"
#include "services/runtime_mode_service.h"
#include "services/register_monitor_service.h"
#include "services/register_comment_service.h"
#include "ui_main_window.h"

#include "domain/project_limits.h"

#include <QActionGroup>
#include <QAbstractSpinBox>
#include <QApplication>
#include <QCloseEvent>
#include <QDialogButtonBox>
#include <QEvent>
#include <QFileDialog>
#include <QGraphicsScene>
#include <QInputDialog>
#include <QIcon>
#include <QLabel>
#include <QLineEdit>
#include <QKeyEvent>
#include <QKeySequence>
#include <QMessageBox>
#include <QMenu>
#include <QPlainTextEdit>
#include <QPushButton>
#include <QStatusBar>
#include <QTabWidget>
#include <QToolBar>
#include <QToolButton>
#include <QTextEdit>
#include <QTimer>

#include <algorithm>

namespace {

bool isTextEditingObject(QObject *object)
{
    QWidget *widget = qobject_cast<QWidget *>(object);
    while (widget != nullptr)
    {
        if (qobject_cast<QLineEdit *>(widget) != nullptr
            || qobject_cast<QTextEdit *>(widget) != nullptr
            || qobject_cast<QPlainTextEdit *>(widget) != nullptr
            || qobject_cast<QAbstractSpinBox *>(widget) != nullptr)
        {
            return true;
        }
        widget = widget->parentWidget();
    }
    return false;
}

QString suggestedProjectFileName(QString project_name)
{
    project_name = project_name.trimmed();
    const QString invalid_characters = QStringLiteral("<>:\"/\\|?*");
    for (QChar &character : project_name)
    {
        if (character.unicode() < 0x20U || invalid_characters.contains(character))
        {
            character = QLatin1Char('_');
        }
    }

    constexpr int kMaximumSuggestedBaseNameLength = 240;
    if (project_name.size() > kMaximumSuggestedBaseNameLength)
    {
        project_name.truncate(kMaximumSuggestedBaseNameLength);
        if (!project_name.isEmpty()
            && project_name.at(project_name.size() - 1).isHighSurrogate())
        {
            project_name.chop(1);
        }
    }
    while (project_name.endsWith(QLatin1Char(' '))
           || project_name.endsWith(QLatin1Char('.')))
    {
        project_name.chop(1);
    }
    if (project_name.isEmpty())
    {
        project_name = QStringLiteral("未命名工程");
    }

    const QString device_name = project_name.section(QLatin1Char('.'), 0, 0).toUpper();
    const bool is_reserved_device_name = device_name == QStringLiteral("CON")
        || device_name == QStringLiteral("PRN")
        || device_name == QStringLiteral("AUX")
        || device_name == QStringLiteral("NUL")
        || (device_name.size() == 4
            && (device_name.startsWith(QStringLiteral("COM"))
                || device_name.startsWith(QStringLiteral("LPT")))
            && device_name.back() >= QLatin1Char('1')
            && device_name.back() <= QLatin1Char('9'));
    if (is_reserved_device_name)
    {
        project_name.prepend(QLatin1Char('_'));
    }
    return project_name + QStringLiteral(".json");
}

bool isEditorShortcut(const QKeyEvent &event)
{
    return event.matches(QKeySequence::Undo)
        || event.matches(QKeySequence::Redo)
        || event.matches(QKeySequence::Copy)
        || event.matches(QKeySequence::Paste)
        || (event.modifiers() == Qt::NoModifier
            && (event.key() == Qt::Key_Delete || event.key() == Qt::Key_Escape));
}

QString modeText(ApplicationMode mode)
{
    switch (mode)
    {
    case ApplicationMode::Editing:
    {
        return MainWindow::tr("编辑态");
    }
    case ApplicationMode::OfflineRunning:
    {
        return MainWindow::tr("离线运行态");
    }
    case ApplicationMode::OnlineRunning:
    {
        return MainWindow::tr("真机运行态");
    }
    default:
    {
        return MainWindow::tr("未知状态");
    }
    }
}

QString transitionErrorText(ModeTransitionError error)
{
    switch (error)
    {
    case ModeTransitionError::MustReturnToEditing:
    {
        return MainWindow::tr("请先返回编辑态，再切换运行模式");
    }
    case ModeTransitionError::InitialPlcReadRequired:
    {
        return MainWindow::tr("真机运行前必须连接 PLC 并完成首次读取");
    }
    case ModeTransitionError::AlreadyInRequestedMode:
    {
        return MainWindow::tr("当前已处于所选模式");
    }
    case ModeTransitionError::ProjectNotReady:
    {
        return MainWindow::tr("工程存在未配置或未完成的 HMI/梯形图节点，暂不能进入运行态");
    }
    case ModeTransitionError::SimulationStartFailed:
    {
        return MainWindow::tr("本地逻辑执行器预检或启动失败");
    }
    case ModeTransitionError::None:
    default:
    {
        return MainWindow::tr("模式切换失败");
    }
    }
}

std::string toUtf8(const QString &value)
{
    const QByteArray bytes = value.toUtf8();
    return std::string(bytes.constData(), static_cast<std::size_t>(bytes.size()));
}

QString fromUtf8(const std::string &value)
{
    return QString::fromUtf8(value.data(), static_cast<int>(value.size()));
}

QString plcStatusText(const RuntimeModeService &service)
{
    switch (service.plcConnectionState())
    {
    case PlcConnectionState::Connecting:
        return MainWindow::tr("PLC 正在连接");
    case PlcConnectionState::Connected:
        return service.initialPlcReadCompleted()
            ? MainWindow::tr("PLC 已连接，首次读取完成")
            : MainWindow::tr("PLC 已连接，正在读取工程使用的 M/D 地址");
    case PlcConnectionState::Recovering:
        return MainWindow::tr("PLC 通信已恢复，正在重新读取工程使用的 M/D 地址");
    case PlcConnectionState::Faulted:
    {
        const QString error = fromUtf8(service.plcError());
        return error.isEmpty()
            ? MainWindow::tr("PLC 通信故障")
            : MainWindow::tr("PLC 通信故障：%1").arg(error);
    }
    case PlcConnectionState::Disconnected:
    {
        const QString error = fromUtf8(service.plcError());
        return error.isEmpty()
            ? MainWindow::tr("PLC 已断开")
            : MainWindow::tr("PLC 已断开：%1").arg(error);
    }
    default:
    {
        return MainWindow::tr("PLC 已断开");
    }
    }
}

QToolButton *addToolbarMenu(
    QToolBar *toolbar,
    const QString &text,
    const QString &object_name,
    const QIcon &icon,
    const QList<QAction *> &actions)
{
    auto *button = new QToolButton(toolbar);
    button->setObjectName(object_name);
    button->setText(text);
    button->setIcon(icon);
    button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
    button->setPopupMode(QToolButton::InstantPopup);

    auto *menu = new QMenu(button);
    menu->addActions(actions);
    button->setMenu(menu);
    toolbar->addWidget(button);
    return button;
}

} // namespace

MainWindow::MainWindow(
    RuntimeModeService &runtime_mode_service,
    ProjectService &project_service,
    HmiEditorService &hmi_editor_service,
    LogicEditorService &logic_editor_service,
    HmiRuntimeService &hmi_runtime_service,
    AlarmEditorService &alarm_editor_service,
    AlarmService &alarm_service,
    RegisterCommentService &register_comment_service,
    RegisterMonitorService &register_monitor_service,
    PlcDiscoveryGateway &plc_discovery_gateway,
    const ApplicationSettingsLoadResult &application_settings_result,
    QWidget *parent)
    : QMainWindow(parent),
      ui_(std::make_unique<Ui::MainWindow>()),
      runtime_mode_service_(runtime_mode_service),
      project_service_(project_service),
      hmi_editor_service_(hmi_editor_service),
      logic_editor_service_(logic_editor_service),
      hmi_runtime_service_(hmi_runtime_service),
      alarm_editor_service_(alarm_editor_service),
      alarm_service_(alarm_service),
      register_comment_service_(register_comment_service),
      register_monitor_service_(register_monitor_service),
      plc_discovery_gateway_(plc_discovery_gateway),
      application_settings_result_(application_settings_result),
      owned_hmi_navigation_service_(
          std::make_unique<HmiNavigationService>(project_service)),
      hmi_navigation_service_(owned_hmi_navigation_service_.get()),
      plc_configuration_(application_settings_result.settings.plcDefaults)
{
    initializeUi();
}

MainWindow::MainWindow(
    RuntimeModeService &runtime_mode_service,
    ProjectService &project_service,
    HmiEditorService &hmi_editor_service,
    LogicEditorService &logic_editor_service,
    HmiRuntimeService &hmi_runtime_service,
    AlarmEditorService &alarm_editor_service,
    AlarmService &alarm_service,
    HmiNavigationService &hmi_navigation_service,
    RegisterCommentService &register_comment_service,
    RegisterMonitorService &register_monitor_service,
    PlcDiscoveryGateway &plc_discovery_gateway,
    const ApplicationSettingsLoadResult &application_settings_result,
    QWidget *parent)
    : QMainWindow(parent),
      ui_(std::make_unique<Ui::MainWindow>()),
      runtime_mode_service_(runtime_mode_service),
      project_service_(project_service),
      hmi_editor_service_(hmi_editor_service),
      logic_editor_service_(logic_editor_service),
      hmi_runtime_service_(hmi_runtime_service),
      alarm_editor_service_(alarm_editor_service),
      alarm_service_(alarm_service),
      register_comment_service_(register_comment_service),
      register_monitor_service_(register_monitor_service),
      plc_discovery_gateway_(plc_discovery_gateway),
      application_settings_result_(application_settings_result),
      hmi_navigation_service_(&hmi_navigation_service),
      plc_configuration_(application_settings_result.settings.plcDefaults)
{
    initializeUi();
}

void MainWindow::initializeUi()
{
    ui_->setupUi(this);
    qApp->installEventFilter(this);
    configureAppearance();
    property_panel_controller_ = std::make_unique<PropertyPanelController>(
        *this,
        *ui_,
        project_service_,
        hmi_editor_service_,
        logic_editor_service_,
        application_settings_result_.settings.hmiDefaults,
        [this] { return current_hmi_page_id_; },
        [this] { return current_logic_id_; },
        selected_control_id_,
        selected_logic_node_id_,
        [this] { refreshProjectUi(); },
        [this](const QString &action, const QString &message, bool succeeded)
        {
            showProjectResult(action, message, succeeded);
        },
        [this](const QString &message, int timeout_ms)
        {
            statusBar()->showMessage(message, timeout_ms);
        });
    configureActions();
    configurePropertyEditor();
    configurePlcConnection();
    configureAlarms();
    configureRegisterComments();
    configureHmiEditor();
    configureLogicEditor();
    configureRuntimeMonitor();
    configureProjectTree();
    runtime_mode_service_.setPlcStatusChangedCallback(
        [this] { schedulePlcStatusUpdate(); });
    hmi_editor_service_.ensureDefaultPage();
    logic_editor_service_.ensureDefaultLogic();
    clearEditorHistories();
    current_hmi_page_id_ = hmi_editor_service_.firstPageId();
    current_logic_id_ = logic_editor_service_.firstLogicId();
    showControlProperties({});
    refreshProjectUi();
    updateModeUi(tr("系统已进入编辑态"));
    for (const std::string &message : application_settings_result_.messages)
    {
        appendOutputMessage(fromUtf8(message));
    }
    if (application_settings_result_.warningRequired)
    {
        const QString warning = fromUtf8(
            application_settings_result_.warningMessage);
        QTimer::singleShot(
            0,
            this,
            [this, warning]
            {
                QMessageBox::warning(this, tr("应用配置"), warning);
            });
    }
}

MainWindow::~MainWindow()
{
    qApp->removeEventFilter(this);
    runtime_mode_service_.setPlcStatusChangedCallback({});
}

bool MainWindow::eventFilter(QObject *watched, QEvent *event)
{
    if (event->type() == QEvent::ShortcutOverride
        && isTextEditingObject(watched))
    {
        auto *key_event = static_cast<QKeyEvent *>(event);
        if (isEditorShortcut(*key_event))
        {
            event->accept();
            return true;
        }
    }
    return QMainWindow::eventFilter(watched, event);
}

void MainWindow::closeEvent(QCloseEvent *event)
{
    if (!confirmSaveBeforeDestructiveAction())
    {
        event->ignore();
        return;
    }
    if (runtime_panel_controller_ != nullptr)
    {
        runtime_panel_controller_->closeForApplicationExit();
    }
    QMainWindow::closeEvent(event);
}

const std::string &MainWindow::currentHmiPageId() const
{
    return current_hmi_page_id_;
}

const std::string &MainWindow::currentLogicId() const
{
    return current_logic_id_;
}

void MainWindow::configureActions()
{
    mode_action_group_ = new QActionGroup(this);
    mode_action_group_->setExclusive(true);
    mode_action_group_->addAction(ui_->editingModeAction);
    mode_action_group_->addAction(ui_->offlineModeAction);
    mode_action_group_->addAction(ui_->onlineModeAction);

    connect(ui_->editingModeAction, &QAction::triggered, this,
            [this] { requestMode(ApplicationMode::Editing); });
    connect(ui_->offlineModeAction, &QAction::triggered, this,
            [this] { requestMode(ApplicationMode::OfflineRunning); });
    connect(ui_->onlineModeAction, &QAction::triggered, this,
            [this] { requestMode(ApplicationMode::OnlineRunning); });
    connect(ui_->exitAction, &QAction::triggered, this, [this] { close(); });
    connect(ui_->newProjectAction, &QAction::triggered, this, &MainWindow::createNewProject);
    connect(ui_->saveProjectAction, &QAction::triggered, this, &MainWindow::saveProject);
    connect(ui_->saveAsProjectAction, &QAction::triggered, this, &MainWindow::saveProjectAs);
    connect(ui_->loadProjectAction, &QAction::triggered, this, &MainWindow::loadProject);
    connect(ui_->undoAction, &QAction::triggered,
            this, &MainWindow::undoActiveEditor);
    connect(ui_->redoAction, &QAction::triggered,
            this, &MainWindow::redoActiveEditor);
    connect(ui_->copyAction, &QAction::triggered,
            this, &MainWindow::copyActiveSelection);
    connect(ui_->pasteAction, &QAction::triggered,
            this, &MainWindow::pasteActiveSelection);
    connect(ui_->deleteSelectionAction, &QAction::triggered,
            this, &MainWindow::deleteActiveSelection);
    connect(ui_->clearSelectionAction, &QAction::triggered,
            this, &MainWindow::clearActiveSelection);

    connect(ui_->addButtonAction, &QAction::triggered, this,
            [this] { addHmiControl(HmiControlType::Button); });
    connect(ui_->addIndicatorAction, &QAction::triggered, this,
            [this] { addHmiControl(HmiControlType::Indicator); });
    connect(ui_->addNumericDisplayAction, &QAction::triggered, this,
            [this] { addHmiControl(HmiControlType::NumericDisplay); });
    connect(ui_->addNumericInputAction, &QAction::triggered, this,
            [this] { addHmiControl(HmiControlType::NumericInput); });
    connect(ui_->addLabelAction, &QAction::triggered, this,
            [this] { addHmiControl(HmiControlType::Label); });
    connect(ui_->addPageJumpAction, &QAction::triggered, this,
            [this] { addHmiControl(HmiControlType::PageJump); });
    connect(ui_->addAlarmListAction, &QAction::triggered, this,
            [this] { addHmiControl(HmiControlType::AlarmList); });
    connect(ui_->deleteControlAction, &QAction::triggered,
            this, &MainWindow::deleteSelectedControl);
    addToolbarMenu(
        ui_->hmiToolBar,
        tr("更多控件"),
        QStringLiteral("hmiMoreControlsButton"),
        makeUiIcon(UiIcon::More),
        QList<QAction *>{
            ui_->addPageJumpAction,
            ui_->addAlarmListAction,
            ui_->configureAlarmsAction});

    connect(ui_->addRungAction, &QAction::triggered,
            this, &MainWindow::addLogicRung);
    connect(ui_->insertHorizontalWireAction, &QAction::triggered,
            this, &MainWindow::addLogicHorizontalWire);
    connect(ui_->insertVerticalWireAction, &QAction::triggered,
            this, &MainWindow::addLogicVerticalWire);
    connect(ui_->deleteHorizontalWireAction, &QAction::triggered,
            this, &MainWindow::deleteLogicHorizontalWire);
    connect(ui_->deleteVerticalWireAction, &QAction::triggered,
            this, &MainWindow::deleteLogicVerticalWire);
    connect(ui_->parallelInsertAction, &QAction::triggered,
            this,
            [this]
            {
                addLogicParallelBranch(ContactNodeConfig{
                    RegisterAddress{RegisterArea::M, 0},
                    ContactMode::NormallyOpen});
            });
    QMenu *parallel_menu = new QMenu(this);
    QAction *parallel_open = parallel_menu->addAction(tr("并联常开触点"));
    QAction *parallel_closed = parallel_menu->addAction(tr("并联常闭触点"));
    QAction *parallel_rising = parallel_menu->addAction(tr("并联上升沿触点"));
    QAction *parallel_falling = parallel_menu->addAction(tr("并联下降沿触点"));
    QAction *parallel_compare = parallel_menu->addAction(tr("并联比较条件"));
    connect(parallel_open, &QAction::triggered,
            this,
            [this]
            {
                addLogicParallelBranch(ContactNodeConfig{
                    RegisterAddress{RegisterArea::M, 0},
                    ContactMode::NormallyOpen});
            });
    connect(parallel_closed, &QAction::triggered,
            this,
            [this]
            {
                addLogicParallelBranch(ContactNodeConfig{
                    RegisterAddress{RegisterArea::M, 0},
                    ContactMode::NormallyClosed});
            });
    connect(parallel_rising, &QAction::triggered,
            this,
            [this]
            {
                addLogicParallelBranch(EdgeContactNodeConfig{
                    RegisterAddress{RegisterArea::M, 0}, EdgeMode::Rising});
            });
    connect(parallel_falling, &QAction::triggered,
            this,
            [this]
            {
                addLogicParallelBranch(EdgeContactNodeConfig{
                    RegisterAddress{RegisterArea::M, 0}, EdgeMode::Falling});
            });
    connect(parallel_compare, &QAction::triggered,
            this,
            [this]
            {
                addLogicParallelBranch(CompareNodeConfig{
                    RegisterAddress{RegisterArea::D, 0},
                    ComparisonOperator::Equal,
                    0});
            });
    ui_->parallelInsertAction->setMenu(parallel_menu);
    if (QToolButton *parallel_button = qobject_cast<QToolButton *>(
            ui_->logicToolBar->widgetForAction(ui_->parallelInsertAction)))
    {
        parallel_button->setPopupMode(QToolButton::MenuButtonPopup);
    }
    connect(ui_->addNormallyOpenAction, &QAction::triggered,
            this,
            [this]
            {
                addLogicCondition(ContactNodeConfig{
                    RegisterAddress{RegisterArea::M, 0},
                    ContactMode::NormallyOpen});
            });
    connect(ui_->addNormallyClosedAction, &QAction::triggered,
            this,
            [this]
            {
                addLogicCondition(ContactNodeConfig{
                    RegisterAddress{RegisterArea::M, 0},
                    ContactMode::NormallyClosed});
            });
    connect(ui_->addRisingEdgeAction, &QAction::triggered,
            this,
            [this]
            {
                addLogicCondition(EdgeContactNodeConfig{
                    RegisterAddress{RegisterArea::M, 0}, EdgeMode::Rising});
            });
    connect(ui_->addFallingEdgeAction, &QAction::triggered,
            this,
            [this]
            {
                addLogicCondition(EdgeContactNodeConfig{
                    RegisterAddress{RegisterArea::M, 0}, EdgeMode::Falling});
            });
    connect(ui_->addNormalCoilAction, &QAction::triggered,
            this,
            [this]
            {
                setLogicOutput(CoilNodeConfig{
                    RegisterAddress{RegisterArea::M, 0},
                    CoilMode::Normal});
            });
    connect(ui_->addSetCoilAction, &QAction::triggered,
            this,
            [this]
            {
                setLogicOutput(CoilNodeConfig{
                    RegisterAddress{RegisterArea::M, 0},
                    CoilMode::Set});
            });
    connect(ui_->addResetCoilAction, &QAction::triggered,
            this,
            [this]
            {
                setLogicOutput(CoilNodeConfig{
                    RegisterAddress{RegisterArea::M, 0},
                    CoilMode::Reset});
            });
    connect(ui_->addMoveAction, &QAction::triggered,
            this,
            [this]
            {
                configureAndSetLogicOutput(MoveNodeConfig{
                    WordOperand{
                        WordOperandKind::Constant,
                        RegisterAddress{RegisterArea::D, 0},
                        0},
                    RegisterAddress{RegisterArea::D, 0}});
            });
    connect(ui_->addAddAction, &QAction::triggered,
            this,
            [this]
            {
                configureAndSetLogicOutput(ArithmeticNodeConfig{
                    ArithmeticOperation::Add,
                    WordOperand{
                        WordOperandKind::Register,
                        RegisterAddress{RegisterArea::D, 0},
                        0},
                    WordOperand{
                        WordOperandKind::Constant,
                        RegisterAddress{RegisterArea::D, 0},
                        1},
                    RegisterAddress{RegisterArea::D, 0}});
            });
    connect(ui_->addSubAction, &QAction::triggered,
            this,
            [this]
            {
                configureAndSetLogicOutput(ArithmeticNodeConfig{
                    ArithmeticOperation::Subtract,
                    WordOperand{
                        WordOperandKind::Register,
                        RegisterAddress{RegisterArea::D, 0},
                        0},
                    WordOperand{
                        WordOperandKind::Constant,
                        RegisterAddress{RegisterArea::D, 0},
                        1},
                    RegisterAddress{RegisterArea::D, 0}});
            });
    connect(ui_->addCompareAction, &QAction::triggered,
            this,
            [this]
            {
                addLogicCondition(CompareNodeConfig{
                    RegisterAddress{RegisterArea::D, 0},
                    ComparisonOperator::Equal,
                    0});
            });
    connect(ui_->deleteLogicAction, &QAction::triggered,
            this, &MainWindow::deleteSelectedLogicObject);
    connect(ui_->editRungCommentAction, &QAction::triggered,
            this, &MainWindow::editSelectedRungComment);
    addToolbarMenu(
        ui_->logicToolBar,
        tr("更多触点"),
        QStringLiteral("logicContactMenuButton"),
        makeUiIcon(UiIcon::NormallyOpenContact),
        QList<QAction *>{
            ui_->addRisingEdgeAction,
            ui_->addFallingEdgeAction});
    addToolbarMenu(
        ui_->logicToolBar,
        tr("更多输出"),
        QStringLiteral("logicOutputMenuButton"),
        makeUiIcon(UiIcon::Coil),
        QList<QAction *>{ui_->addSetCoilAction, ui_->addResetCoilAction});
    addToolbarMenu(
        ui_->logicToolBar,
        tr("数据运算"),
        QStringLiteral("logicDataMenuButton"),
        makeUiIcon(UiIcon::Move),
        QList<QAction *>{
            ui_->addMoveAction,
            ui_->addAddAction,
            ui_->addSubAction,
            ui_->addCompareAction});

    connect(ui_->editorTabWidget, &QTabWidget::currentChanged,
            this,
            [this](int index)
            {
                ui_->hmiToolBar->setVisible(index == 0);
                ui_->logicToolBar->setVisible(index == 1);
                if (index == 0)
                {
                    showControlProperties(selected_control_id_);
                }
                else if (index == 1)
                {
                    showLogicNodeProperties(selected_logic_node_id_);
                }
                if (index == 0 || index == 1)
                {
                    refreshProjectUi();
                }
            });
    ui_->hmiToolBar->setVisible(ui_->editorTabWidget->currentIndex() == 0);
    ui_->logicToolBar->setVisible(ui_->editorTabWidget->currentIndex() == 1);

    ui_->viewMenu->addAction(ui_->projectDock->toggleViewAction());
    ui_->viewMenu->addAction(ui_->propertiesDock->toggleViewAction());
    ui_->viewMenu->addAction(ui_->outputDock->toggleViewAction());
    ui_->viewMenu->addAction(ui_->hmiToolBar->toggleViewAction());
    ui_->viewMenu->addAction(ui_->logicToolBar->toggleViewAction());
    ui_->viewMenu->addSeparator();
    ui_->viewMenu->addAction(ui_->modeToolBar->toggleViewAction());
}

void MainWindow::configureAppearance()
{
    setDockNestingEnabled(true);
    setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
    setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);

    ui_->editingModeAction->setIcon(makeUiIcon(UiIcon::Edit));
    ui_->offlineModeAction->setIcon(makeUiIcon(UiIcon::RunOffline));
    ui_->onlineModeAction->setIcon(makeUiIcon(UiIcon::RunOnline));
    ui_->newProjectAction->setIcon(makeUiIcon(UiIcon::NewDocument));
    ui_->saveProjectAction->setIcon(makeUiIcon(UiIcon::Save));
    ui_->saveAsProjectAction->setIcon(makeUiIcon(UiIcon::SaveAs));
    ui_->loadProjectAction->setIcon(makeUiIcon(UiIcon::Open));
    ui_->undoAction->setIcon(makeUiIcon(UiIcon::Undo));
    ui_->redoAction->setIcon(makeUiIcon(UiIcon::Redo));
    ui_->deleteSelectionAction->setIcon(makeUiIcon(UiIcon::Delete));
    ui_->clearSelectionAction->setIcon(makeUiIcon(UiIcon::ClearList));
    ui_->exitAction->setIcon(makeUiIcon(UiIcon::Exit));
    ui_->configurePlcAction->setIcon(makeUiIcon(UiIcon::PlcSettings));
    ui_->disconnectPlcAction->setIcon(makeUiIcon(UiIcon::Disconnect));
    ui_->configureRegisterCommentsAction->setIcon(
        makeUiIcon(UiIcon::RegisterComments));
    ui_->addButtonAction->setIcon(makeUiIcon(UiIcon::HmiButton));
    ui_->addIndicatorAction->setIcon(makeUiIcon(UiIcon::Indicator));
    ui_->addNumericDisplayAction->setIcon(makeUiIcon(UiIcon::NumericDisplay));
    ui_->addNumericInputAction->setIcon(makeUiIcon(UiIcon::NumericInput));
    ui_->addLabelAction->setIcon(makeUiIcon(UiIcon::Text));
    ui_->addPageJumpAction->setIcon(makeUiIcon(UiIcon::PageJump));
    ui_->addAlarmListAction->setIcon(makeUiIcon(UiIcon::AlarmList));
    ui_->configureAlarmsAction->setIcon(makeUiIcon(UiIcon::AlarmSettings));
    ui_->deleteControlAction->setIcon(makeUiIcon(UiIcon::Delete));
    ui_->addRungAction->setIcon(makeUiIcon(UiIcon::AddRung));
    ui_->parallelInsertAction->setIcon(makeUiIcon(UiIcon::ParallelBranch));
    ui_->insertHorizontalWireAction->setIcon(makeUiIcon(UiIcon::HorizontalWire));
    ui_->insertVerticalWireAction->setIcon(makeUiIcon(UiIcon::VerticalWire));
    ui_->deleteHorizontalWireAction->setIcon(makeUiIcon(UiIcon::Delete));
    ui_->deleteVerticalWireAction->setIcon(makeUiIcon(UiIcon::Delete));
    ui_->addNormallyOpenAction->setIcon(makeUiIcon(UiIcon::NormallyOpenContact));
    ui_->addNormallyClosedAction->setIcon(makeUiIcon(UiIcon::NormallyClosedContact));
    ui_->addRisingEdgeAction->setIcon(makeUiIcon(UiIcon::RisingEdgeContact));
    ui_->addFallingEdgeAction->setIcon(makeUiIcon(UiIcon::FallingEdgeContact));
    ui_->addNormalCoilAction->setIcon(makeUiIcon(UiIcon::Coil));
    ui_->addSetCoilAction->setIcon(makeUiIcon(UiIcon::SetCoil));
    ui_->addResetCoilAction->setIcon(makeUiIcon(UiIcon::ResetCoil));
    ui_->addMoveAction->setIcon(makeUiIcon(UiIcon::Move));
    ui_->addAddAction->setIcon(makeUiIcon(UiIcon::Add));
    ui_->addSubAction->setIcon(makeUiIcon(UiIcon::Subtract));
    ui_->addCompareAction->setIcon(makeUiIcon(UiIcon::Compare));
    ui_->editRungCommentAction->setIcon(makeUiIcon(UiIcon::Comment));
    ui_->deleteLogicAction->setIcon(makeUiIcon(UiIcon::Delete));
    ui_->editorTabWidget->setTabIcon(0, makeUiIcon(UiIcon::HmiPage));
    ui_->editorTabWidget->setTabIcon(1, makeUiIcon(UiIcon::Logic));
    ui_->outputDock->setMaximumHeight(220);

    mode_status_label_ = new QLabel(this);
    mode_status_label_->setObjectName(QStringLiteral("modeStatusLabel"));
    mode_status_label_->setMinimumWidth(88);
    mode_status_label_->setAlignment(Qt::AlignCenter);
    register_status_label_ = new QLabel(this);
    register_status_label_->setObjectName(QStringLiteral("registerStatusLabel"));
    register_status_label_->setMinimumWidth(132);
    executor_status_label_ = new QLabel(this);
    executor_status_label_->setObjectName(QStringLiteral("executorStatusLabel"));
    executor_status_label_->setMinimumWidth(132);
    statusBar()->addPermanentWidget(mode_status_label_);
    statusBar()->addPermanentWidget(register_status_label_);
    statusBar()->addPermanentWidget(executor_status_label_);

    setStyleSheet(QStringLiteral(
        "QMainWindow { background: #f3f5f7; }"
        "QToolBar { background: #ffffff; border: 0; border-bottom: 1px solid #cbd2d9;"
        " padding: 4px; spacing: 3px; }"
        "QToolButton { min-height: 26px; padding: 3px 9px; border: 1px solid transparent; }"
        "QToolButton:hover { background: #edf2f6; border-color: #c5ced6; }"
        "QToolButton:checked { background: #dcece3; border-color: #75a58a; }"
        "QDockWidget { color: #24313b; font-weight: 600; }"
        "QDockWidget::title { background: #e9edf0; padding: 6px;"
        " border-bottom: 1px solid #cbd2d9; }"
        "QTreeWidget, QListWidget, QScrollArea { background: #ffffff; border: 1px solid #d5dbe0; }"
        "QTabWidget::pane { border: 0; background: #f3f5f7; }"
        "QTabBar::tab { background: #e5e9ec; padding: 7px 14px; border-right: 1px solid #cbd2d9; }"
        "QTabBar::tab:selected { background: #ffffff; color: #15232d; }"
        "QFrame#hmiCanvasPlaceholder, QFrame#logicCanvasPlaceholder { background: #ffffff;"
        " border: 1px solid #cbd2d9; }"
        "QLabel#hmiEmptyLabel, QLabel#logicEmptyLabel { color: #75838d; }"
        "QLabel#hmiPageTitleLabel { color: #1d2a33; font-weight: 600; }"
        "QLabel#hmiPageSizeLabel { color: #66747e; }"));
}

void MainWindow::configureHmiEditor()
{
    QLayout *layout = ui_->hmiCanvasPlaceholder->layout();
    delete ui_->hmiEmptyLabel;
    hmi_editor_widget_ = new HmiEditorWidget(
        hmi_editor_service_,
        hmi_runtime_service_,
        alarm_service_,
        ui_->hmiCanvasPlaceholder);
    hmi_editor_widget_->setMinimumHeight(320);
    layout->addWidget(hmi_editor_widget_);
}

void MainWindow::configureLogicEditor()
{
    QLayout *layout = ui_->logicCanvasPlaceholder->layout();
    delete ui_->logicEmptyLabel;
    logic_editor_widget_ = new LogicEditorWidget(
        logic_editor_service_, ui_->logicCanvasPlaceholder);
    logic_editor_widget_->setObjectName(QStringLiteral("logicEditorWidget"));
    logic_editor_widget_->setMinimumHeight(320);
    layout->addWidget(logic_editor_widget_);
    property_panel_controller_->bindEditorWidgets(
        *hmi_editor_widget_, *logic_editor_widget_);
}

void MainWindow::configureRuntimeMonitor()
{
    runtime_panel_controller_ = std::make_unique<RuntimePanelController>(
        *this,
        runtime_mode_service_,
        project_service_,
        hmi_editor_service_,
        hmi_runtime_service_,
        logic_editor_service_,
        *hmi_navigation_service_,
        alarm_service_,
        register_monitor_service_,
        *hmi_editor_widget_,
        *logic_editor_widget_,
        *executor_status_label_,
        [this] { return current_logic_id_; },
        [this](const std::string &logic_id) { current_logic_id_ = logic_id; },
        [this](const std::string &node_id)
        {
            showLogicNodeProperties(node_id);
        },
        [this](const QString &message, int timeout_ms)
        {
            statusBar()->showMessage(message, timeout_ms);
        },
        [this](const QString &message)
        {
            appendOutputMessage(message);
        },
        [this]
        {
            requestMode(ApplicationMode::Editing);
        });
    runtime_panel_controller_->configure();
    runtime_monitor_widget_ = runtime_panel_controller_->runtimeMonitorWidget();
}

void MainWindow::configureProjectTree()
{
    project_workspace_controller_ = std::make_unique<ProjectWorkspaceController>(
        *this,
        *ui_,
        project_service_,
        hmi_editor_service_,
        logic_editor_service_,
        runtime_mode_service_,
        *hmi_navigation_service_,
        *hmi_editor_widget_,
        *logic_editor_widget_,
        *runtime_monitor_widget_,
        current_hmi_page_id_,
        current_logic_id_,
        [this](const std::string &control_id)
        {
            showControlProperties(control_id);
        },
        [this](const std::string &node_id)
        {
            showLogicNodeProperties(node_id);
        },
        [this](const QString &action, const QString &message, bool succeeded)
        {
            showProjectResult(action, message, succeeded);
        },
        [this](const QString &message, int timeout_ms)
        {
            statusBar()->showMessage(message, timeout_ms);
        },
        [this]
        {
            updateEditActions();
        });
    project_workspace_controller_->configure();
}

void MainWindow::configurePropertyEditor()
{
    property_panel_controller_->configure();
}

void MainWindow::configurePlcConnection()
{
    connect(ui_->configurePlcAction, &QAction::triggered, this, &MainWindow::connectPlc);
    connect(ui_->disconnectPlcAction, &QAction::triggered, this, &MainWindow::disconnectPlc);
}

void MainWindow::configureAlarms()
{
    connect(ui_->configureAlarmsAction, &QAction::triggered,
            this,
            [this]
            {
                AlarmConfigurationDialog dialog(alarm_editor_service_, this);
                dialog.exec();
                refreshProjectUi();
    });
}

void MainWindow::configureRegisterComments()
{
    connect(
        ui_->configureRegisterCommentsAction,
        &QAction::triggered,
        this,
        [this]
        {
            RegisterCommentDialog dialog(register_comment_service_, this);
            dialog.exec();
            logic_editor_widget_->reloadLogic();
            refreshProjectUi();
        });
}

void MainWindow::undoActiveEditor()
{
    if (!runtime_mode_service_.policy().allowsProjectEditing)
    {
        return;
    }
    if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)
    {
        if (!hmi_editor_service_.undo().succeeded)
        {
            return;
        }
        selected_control_id_.clear();
        showControlProperties({});
        refreshProjectUi();
        hmi_editor_widget_->reloadPage();
        statusBar()->showMessage(tr("已撤销 HMI 编辑操作"), 3000);
    }
    else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)
    {
        if (!logic_editor_service_.undo().succeeded)
        {
            return;
        }
        selected_logic_node_id_.clear();
        showLogicNodeProperties({});
        refreshProjectUi();
        logic_editor_widget_->reloadLogic();
        statusBar()->showMessage(tr("已撤销梯形图编辑操作"), 3000);
    }
    updateEditActions();
}

void MainWindow::redoActiveEditor()
{
    if (!runtime_mode_service_.policy().allowsProjectEditing)
    {
        return;
    }
    if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)
    {
        if (!hmi_editor_service_.redo().succeeded)
        {
            return;
        }
        selected_control_id_.clear();
        showControlProperties({});
        refreshProjectUi();
        hmi_editor_widget_->reloadPage();
        statusBar()->showMessage(tr("已重做 HMI 编辑操作"), 3000);
    }
    else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)
    {
        if (!logic_editor_service_.redo().succeeded)
        {
            return;
        }
        selected_logic_node_id_.clear();
        showLogicNodeProperties({});
        refreshProjectUi();
        logic_editor_widget_->reloadLogic();
        statusBar()->showMessage(tr("已重做梯形图编辑操作"), 3000);
    }
    updateEditActions();
}

void MainWindow::copyActiveSelection()
{
    if (!runtime_mode_service_.policy().allowsProjectEditing
        || isTextEditingObject(qApp->focusWidget()))
    {
        return;
    }
    if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)
    {
        const std::vector<std::string> ids = hmi_editor_widget_->selectedControlIds();
        std::vector<HmiControl> controls;
        controls.reserve(ids.size());
        for (const std::string &id : ids)
        {
            const HmiControl *control = hmi_editor_service_.findControl(
                current_hmi_page_id_, id);
            if (control != nullptr)
            {
                controls.push_back(*control);
            }
        }
        if (controls.empty())
        {
            return;
        }
        editor_clipboard_ = HmiClipboardData{std::move(controls), 0};
        statusBar()->showMessage(tr("已复制 %1 个 HMI 控件").arg(ids.size()), 3000);
    }
    else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)
    {
        const std::vector<std::string> ids = logic_editor_widget_->selectedNodeIds();
        if (!ids.empty())
        {
            const std::string rung_id = logic_editor_widget_->selectedRungId();
            if (rung_id.empty())
            {
                statusBar()->showMessage(tr("只能复制同一网络中的梯形图指令"), 3000);
                return;
            }
            std::vector<LogicNode> nodes;
            nodes.reserve(ids.size());
            bool all_conditions = true;
            for (const std::string &id : ids)
            {
                const LogicNode *node = logic_editor_service_.findNode(
                    current_logic_id_, id);
                if (node == nullptr)
                {
                    return;
                }
                all_conditions = all_conditions && node->isCondition();
                nodes.push_back(*node);
            }
            if (all_conditions
                && logic_editor_service_.areConditionNodesContiguous(
                    current_logic_id_, rung_id, ids))
            {
                editor_clipboard_ = LogicNodesClipboardData{std::move(nodes)};
                statusBar()->showMessage(tr("已复制 %1 个梯形图条件").arg(ids.size()), 3000);
            }
            else if (ids.size() == 1U && nodes.front().isOutput())
            {
                editor_clipboard_ = LogicOutputClipboardData{nodes.front()};
                statusBar()->showMessage(tr("已复制梯形图输出指令"), 3000);
            }
            else
            {
                statusBar()->showMessage(
                    tr("只能复制同一串联层级中连续的条件，或单个输出指令"), 3000);
            }
            updateEditActions();
            return;
        }

        const std::string rung_id = logic_editor_widget_->selectedRungId();
        const LadderRung *rung = logic_editor_service_.findRung(
            current_logic_id_, rung_id);
        if (rung != nullptr)
        {
            editor_clipboard_ = LogicRungClipboardData{*rung};
            statusBar()->showMessage(tr("已复制整条梯形图网络"), 3000);
        }
    }
    updateEditActions();
}

void MainWindow::pasteActiveSelection()
{
    if (!runtime_mode_service_.policy().allowsProjectEditing
        || isTextEditingObject(qApp->focusWidget()))
    {
        return;
    }
    if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)
    {
        auto *data = std::get_if<HmiClipboardData>(&editor_clipboard_);
        if (data == nullptr)
        {
            return;
        }
        const int offset = 20 * std::min(data->pasteCount + 1, 10);
        const HmiEditorResult result = hmi_editor_service_.pasteControls(
            current_hmi_page_id_, data->controls, offset, offset);
        if (!result.succeeded)
        {
            showProjectResult(tr("粘贴 HMI 控件"), fromUtf8(result.message), false);
            return;
        }
        ++data->pasteCount;
        refreshProjectUi();
        hmi_editor_widget_->reloadPage();
        hmi_editor_widget_->selectControl(result.id);
        showControlProperties(result.id);
        statusBar()->showMessage(tr("已粘贴 HMI 控件"), 3000);
    }
    else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)
    {
        LogicEditorResult result;
        if (const auto *data = std::get_if<LogicNodesClipboardData>(&editor_clipboard_))
        {
            result = logic_editor_widget_->pasteConditionNodes(data->nodes);
            if (result.succeeded)
            {
                selected_logic_node_id_ = result.id;
                showLogicNodeProperties(result.id);
            }
        }
        else if (const auto *data = std::get_if<LogicOutputClipboardData>(&editor_clipboard_))
        {
            result = logic_editor_widget_->setOutput(
                data->output.config, data->output.configured);
        }
        else if (const auto *data = std::get_if<LogicRungClipboardData>(&editor_clipboard_))
        {
            result = logic_editor_service_.pasteRung(current_logic_id_, data->rung);
            if (result.succeeded)
            {
                logic_editor_widget_->reloadLogic();
            }
        }
        if (!result.succeeded)
        {
            if (!result.message.empty())
            {
                showProjectResult(tr("粘贴梯形图"), fromUtf8(result.message), false);
            }
            return;
        }
        refreshProjectUi();
        statusBar()->showMessage(tr("已粘贴梯形图对象"), 3000);
    }
    updateEditActions();
}

void MainWindow::deleteActiveSelection()
{
    if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)
    {
        deleteSelectedControl();
    }
    else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)
    {
        deleteSelectedLogicObject();
    }
}

void MainWindow::clearActiveSelection()
{
    if (ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab)
    {
        hmi_editor_widget_->scene()->clearSelection();
        selected_control_id_.clear();
        showControlProperties({});
    }
    else if (ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab)
    {
        logic_editor_widget_->scene()->clearSelection();
        selected_logic_node_id_.clear();
        showLogicNodeProperties({});
    }
}

void MainWindow::updateEditActions()
{
    const bool editable = runtime_mode_service_.policy().allowsProjectEditing;
    const bool hmi_active = ui_->editorTabWidget->currentWidget() == ui_->hmiEditorTab;
    const bool logic_active =
        ui_->editorTabWidget->currentWidget() == ui_->logicEditorTab;
    ui_->undoAction->setEnabled(
        editable && ((hmi_active && hmi_editor_service_.canUndo())
                     || (logic_active && logic_editor_service_.canUndo())));
    ui_->redoAction->setEnabled(
        editable && ((hmi_active && hmi_editor_service_.canRedo())
                     || (logic_active && logic_editor_service_.canRedo())));
    ui_->copyAction->setEnabled(editable && (hmi_active || logic_active));
    const bool hmi_clipboard = std::holds_alternative<HmiClipboardData>(editor_clipboard_);
    const bool logic_clipboard = std::holds_alternative<LogicNodesClipboardData>(editor_clipboard_)
        || std::holds_alternative<LogicOutputClipboardData>(editor_clipboard_)
        || std::holds_alternative<LogicRungClipboardData>(editor_clipboard_);
    ui_->pasteAction->setEnabled(editable && ((hmi_active && hmi_clipboard)
                                              || (logic_active && logic_clipboard)));
    ui_->deleteSelectionAction->setEnabled(editable && (hmi_active || logic_active));
    ui_->clearSelectionAction->setEnabled(editable && (hmi_active || logic_active));
    ui_->insertHorizontalWireAction->setEnabled(editable && logic_active);
    ui_->insertVerticalWireAction->setEnabled(editable && logic_active);
    ui_->deleteHorizontalWireAction->setEnabled(editable && logic_active);
    ui_->deleteVerticalWireAction->setEnabled(editable && logic_active);
}

void MainWindow::clearEditorHistories()
{
    hmi_editor_service_.clearHistory();
    logic_editor_service_.clearHistory();
    if (ui_->undoAction != nullptr)
    {
        updateEditActions();
    }
}

void MainWindow::refreshProjectUi()
{
    project_workspace_controller_->refresh();
    updateEditActions();
    updateWindowTitle();
}

void MainWindow::updateWindowTitle()
{
    QString title = tr("综合平台编程器");
    if (project_service_.isModified())
    {
        title += QStringLiteral("*");
    }
    setWindowTitle(title);
}

bool MainWindow::confirmSaveBeforeDestructiveAction()
{
    if (!project_service_.isModified())
    {
        return true;
    }

    const QString project_name = fromUtf8(project_service_.project().metadata.name);
    const QMessageBox::StandardButton choice = QMessageBox::warning(
        this,
        tr("工程尚未保存"),
        tr("工程“%1”有未保存的修改，是否先保存？").arg(project_name),
        QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel,
        QMessageBox::Save);
    if (choice == QMessageBox::Cancel)
    {
        return false;
    }
    if (choice == QMessageBox::Discard)
    {
        return true;
    }

    saveProject();
    return !project_service_.isModified();
}

void MainWindow::updateProjectTreeActions()
{
    project_workspace_controller_->updateActions();
}

void MainWindow::connectPlc()
{
    PlcConnectionDialog dialog(
        plc_configuration_,
        plc_discovery_gateway_,
        [this] { runtime_mode_service_.disconnectPlc(); },
        this);
    if (dialog.exec() != QDialog::Accepted)
    {
        return;
    }
    plc_configuration_ = dialog.configuration();
    if (plc_configuration_.portName.empty())
    {
        showProjectResult(tr("连接 PLC"), tr("请选择或输入串口端口"), false);
        return;
    }
    const PlcCommunicationResult result = runtime_mode_service_.connectPlc(
        plc_configuration_);
    if (!result.succeeded)
    {
        const QString message = fromUtf8(result.message);
        if (result.message == runtime_mode_service_.plcError())
        {
            statusBar()->showMessage(message, 5000);
            QMessageBox::warning(this, tr("连接 PLC"), message);
        }
        else
        {
            showProjectResult(tr("连接 PLC"), message, false);
        }
        return;
    }
    statusBar()->showMessage(tr("PLC 正在连接，等待首次 M/D 读取"), 5000);
}

void MainWindow::disconnectPlc()
{
    runtime_mode_service_.disconnectPlc();
}

void MainWindow::schedulePlcStatusUpdate()
{
    if (plc_status_update_pending_)
    {
        return;
    }
    plc_status_update_pending_ = true;
    QMetaObject::invokeMethod(
        this,
        [this]
        {
            plc_status_update_pending_ = false;
            updateModeUi(plcStatusText(runtime_mode_service_));
        },
        Qt::QueuedConnection);
}

// 根据控件ID加载控件属性到右侧属性面板
void MainWindow::showControlProperties(const std::string &control_id)
{
    property_panel_controller_->showControlProperties(control_id);
}

void MainWindow::showLogicNodeProperties(const std::string &node_id)
{
    property_panel_controller_->showLogicNodeProperties(node_id);
}

void MainWindow::addHmiControl(HmiControlType type)
{
    property_panel_controller_->addHmiControl(type);
}

void MainWindow::deleteSelectedControl()
{
    property_panel_controller_->deleteSelectedControl();
}

void MainWindow::addLogicCondition(const LogicNodeConfig &config)
{
    const LogicEditorResult result = logic_editor_widget_->addCondition(config);
    if (!result.succeeded)
    {
        showProjectResult(tr("添加逻辑条件"), fromUtf8(result.message), false);
        return;
    }
    selected_logic_node_id_ = result.id;
    showLogicNodeProperties(result.id);
    refreshProjectUi();
    statusBar()->showMessage(tr("已添加逻辑条件"), 3000);
}

void MainWindow::addLogicParallelBranch(const LogicNodeConfig &config)
{
    const LogicEditorResult result = logic_editor_widget_->addParallelBranch(config);
    if (!result.succeeded)
    {
        showProjectResult(tr("建立并联支路"), fromUtf8(result.message), false);
        return;
    }
    selected_logic_node_id_ = result.id;
    showLogicNodeProperties(result.id);
    refreshProjectUi();
    statusBar()->showMessage(tr("已建立并联支路，请配置新触点"), 3000);
}

void MainWindow::addLogicHorizontalWire()
{
    const LogicEditorResult result = logic_editor_widget_->addHorizontalWire();
    if (!result.succeeded)
    {
        showProjectResult(tr("插入横线"), fromUtf8(result.message), false);
        return;
    }
    selected_logic_node_id_.clear();
    showLogicNodeProperties({});
    refreshProjectUi();
    statusBar()->showMessage(tr("横线已插入，可直接用触点替换"), 3000);
}

void MainWindow::addLogicVerticalWire()
{
    const LogicEditorResult result = logic_editor_widget_->addVerticalWire();
    if (!result.succeeded)
    {
        showProjectResult(tr("插入竖线"), fromUtf8(result.message), false);
        return;
    }
    selected_logic_node_id_.clear();
    showLogicNodeProperties({});
    refreshProjectUi();
    statusBar()->showMessage(tr("已建立横线旁路和竖线连接"), 3000);
}

void MainWindow::deleteLogicHorizontalWire()
{
    const LogicEditorResult result = logic_editor_widget_->deleteHorizontalWire();
    if (!result.succeeded)
    {
        showProjectResult(tr("删除横线"), fromUtf8(result.message), false);
        return;
    }
    selected_logic_node_id_.clear();
    showLogicNodeProperties({});
    refreshProjectUi();
    statusBar()->showMessage(tr("横线已删除"), 3000);
}

void MainWindow::deleteLogicVerticalWire()
{
    const LogicEditorResult result = logic_editor_widget_->deleteVerticalWire();
    if (!result.succeeded)
    {
        showProjectResult(tr("删除竖线"), fromUtf8(result.message), false);
        return;
    }
    selected_logic_node_id_.clear();
    showLogicNodeProperties({});
    refreshProjectUi();
    statusBar()->showMessage(tr("竖线及对应并联支路已删除"), 3000);
}

void MainWindow::setLogicOutput(const LogicNodeConfig &config)
{
    const LogicEditorResult result = logic_editor_widget_->setOutput(config);
    if (!result.succeeded)
    {
        showProjectResult(tr("设置逻辑输出"), fromUtf8(result.message), false);
        return;
    }
    selected_logic_node_id_ = result.id;
    showLogicNodeProperties(result.id);
    refreshProjectUi();
    statusBar()->showMessage(tr("逻辑输出已设置"), 3000);
}

void MainWindow::configureAndSetLogicOutput(const LogicNodeConfig &config)
{
    LogicInstructionDialog dialog(config, this);
    if (dialog.exec() != QDialog::Accepted)
    {
        return;
    }
    const LogicNodeConfig configured = dialog.config();
    LogicEditorResult result = logic_editor_widget_->setOutput(configured, true);
    if (!result.succeeded)
    {
        showProjectResult(tr("设置逻辑输出"), fromUtf8(result.message), false);
        return;
    }
    const std::string node_id = result.id;
    selected_logic_node_id_ = node_id;
    showLogicNodeProperties(node_id);
    refreshProjectUi();
    statusBar()->showMessage(tr("逻辑输出已配置"), 3000);
}

void MainWindow::addLogicRung()
{
    const LogicEditorResult result = logic_editor_widget_->addRung();
    if (!result.succeeded)
    {
        showProjectResult(tr("新建网络"), fromUtf8(result.message), false);
        return;
    }
    selected_logic_node_id_.clear();
    showLogicNodeProperties({});
    refreshProjectUi();
    statusBar()->showMessage(tr("已新建网络"), 3000);
}

void MainWindow::editSelectedRungComment()
{
    const std::string rung_id = logic_editor_widget_->selectedRungId();
    if (rung_id.empty())
    {
        showProjectResult(tr("网络注释"), tr("请先选择一个梯形图网络"), false);
        return;
    }
    const LadderRung *rung = logic_editor_service_.findRung(
        current_logic_id_, rung_id);
    if (rung == nullptr)
    {
        return;
    }
    bool accepted = false;
    const QString comment = QInputDialog::getText(
        this,
        tr("网络注释"),
        tr("说明"),
        QLineEdit::Normal,
        fromUtf8(rung->comment),
        &accepted);
    if (!accepted)
    {
        return;
    }
    const LogicEditorResult result = logic_editor_service_.updateRungComment(
        current_logic_id_, rung_id, toUtf8(comment));
    if (!result.succeeded)
    {
        showProjectResult(tr("网络注释"), fromUtf8(result.message), false);
        return;
    }
    logic_editor_widget_->reloadLogic();
    refreshProjectUi();
    statusBar()->showMessage(tr("网络注释已更新"), 3000);
}

void MainWindow::deleteSelectedLogicObject()
{
    const LogicEditorResult result = logic_editor_widget_->deleteSelected();
    if (!result.succeeded)
    {
        return;
    }
    selected_logic_node_id_.clear();
    showLogicNodeProperties({});
    refreshProjectUi();
}

void MainWindow::createNewProject()
{
    if (!confirmSaveBeforeDestructiveAction())
    {
        return;
    }

    QInputDialog name_dialog(this);
    name_dialog.setWindowTitle(tr("新建工程"));
    name_dialog.setLabelText(tr("工程名称"));
    name_dialog.setInputMode(QInputDialog::TextInput);

    QDialogButtonBox *button_box = name_dialog.findChild<QDialogButtonBox *>();
    QPushButton *ok_button = button_box != nullptr
        ? button_box->button(QDialogButtonBox::Ok)
        : nullptr;
    if (ok_button != nullptr)
    {
        ok_button->setEnabled(false);
        connect(&name_dialog,
                &QInputDialog::textValueChanged,
                &name_dialog,
                [ok_button](const QString &text) {
                    ok_button->setEnabled(!text.trimmed().isEmpty());
                });
    }

    if (name_dialog.exec() != QDialog::Accepted)
    {
        return;
    }
    const QString name = name_dialog.textValue().trimmed();
    const ProjectOperationResult result = project_service_.createNewProject(toUtf8(name));
    if (!result.succeeded)
    {
        showProjectResult(tr("新建工程"), fromUtf8(result.message), false);
        return;
    }
    hmi_editor_service_.ensureDefaultPage();
    logic_editor_service_.ensureDefaultLogic();
    clearEditorHistories();
    selected_control_id_.clear();
    selected_logic_node_id_.clear();
    editor_clipboard_ = std::monostate{};
    current_hmi_page_id_ = project_service_.project().initialHmiPageId;
    current_logic_id_ = logic_editor_service_.firstLogicId();
    refreshProjectUi();
    hmi_editor_widget_->reloadPage();
    logic_editor_widget_->reloadLogic();
    showControlProperties({});
    statusBar()->showMessage(tr("已创建新工程"), 3000);
}

void MainWindow::saveProject()
{
    if (!project_service_.hasCurrentFile())
    {
        saveProjectAs();
        return;
    }
    const ProjectOperationResult result = project_service_.save();
    if (!result.succeeded)
    {
        showProjectResult(tr("保存工程"), fromUtf8(result.message), false);
        return;
    }
    updateWindowTitle();
    showProjectResult(tr("保存工程"), tr("工程已保存"), true);
}

void MainWindow::saveProjectAs()
{
    const QString suggested_file_name = suggestedProjectFileName(
        fromUtf8(project_service_.project().metadata.name));
    const QString path = QFileDialog::getSaveFileName(
        this,
        tr("工程另存为"),
        suggested_file_name,
        tr("工程文件 (*.json)"));
    if (path.isEmpty())
    {
        return;
    }
    const ProjectOperationResult result = project_service_.saveAs(toUtf8(path));
    if (result.succeeded)
    {
        updateWindowTitle();
    }
    showProjectResult(
        tr("保存工程"),
        result.succeeded ? tr("工程已保存") : fromUtf8(result.message),
        result.succeeded);
}

void MainWindow::loadProject()
{
    if (!confirmSaveBeforeDestructiveAction())
    {
        return;
    }
    const QString path = QFileDialog::getOpenFileName(
        this, tr("加载工程"), {}, tr("工程文件 (*.json)"));
    if (path.isEmpty())
    {
        return;
    }
    const ProjectOperationResult result = project_service_.load(toUtf8(path));
    if (!result.succeeded)
    {
        showProjectResult(tr("加载工程"), fromUtf8(result.message), false);
        return;
    }
    clearEditorHistories();
    selected_control_id_.clear();
    selected_logic_node_id_.clear();
    editor_clipboard_ = std::monostate{};
    current_hmi_page_id_ = project_service_.project().initialHmiPageId;
    current_logic_id_ = logic_editor_service_.firstLogicId();
    refreshProjectUi();
    hmi_editor_widget_->reloadPage();
    logic_editor_widget_->reloadLogic();
    showControlProperties({});
    showProjectResult(tr("加载工程"), tr("工程已加载"), true);
}

void MainWindow::showProjectResult(
    const QString &action, const QString &message, bool succeeded)
{
    const QString output = action + QStringLiteral(": ") + message;
    statusBar()->showMessage(output, 5000);
    appendOutputMessage(output);
    if (!succeeded)
    {
        QMessageBox::warning(this, action, message);
    }
}

void MainWindow::appendOutputMessage(const QString &message)
{
    const int maximum = application_settings_result_
        .settings.projectLimits.maximumOutputMessages;
    while (ui_->outputList->count() >= maximum)
    {
        delete ui_->outputList->takeItem(0);
    }
    ui_->outputList->addItem(message);
    ui_->outputList->scrollToBottom();
}

void MainWindow::requestMode(ApplicationMode requested_mode)
{
    // UI 动作只提出目标模式，所有前置条件和仓库切换由 RuntimeModeService 决定
    // UI 仅转发模式意图，合法性由服务层和领域状态机决定
    ModeTransitionResult result;
    switch (requested_mode)
    {
    case ApplicationMode::Editing:
    {
        result = runtime_mode_service_.enterEditing();
        break;
    }
    case ApplicationMode::OfflineRunning:
    {
        result = runtime_mode_service_.enterOfflineRunning();
        break;
    }
    case ApplicationMode::OnlineRunning:
    {
        result = runtime_mode_service_.enterOnlineRunning();
        break;
    }
    default:
    {
        restoreCurrentModeAction();
        statusBar()->showMessage(tr("不支持的运行模式"), 5000);
        return;
    }
    }
    if (!result.succeeded)
    {
        restoreCurrentModeAction();
        QString message = transitionErrorText(result.error);
        if (result.error == ModeTransitionError::InitialPlcReadRequired)
        {
            message += tr("；当前状态：%1").arg(plcStatusText(runtime_mode_service_));
        }
        if (result.error == ModeTransitionError::SimulationStartFailed)
        {
            const LogicScanResult &error = requested_mode
                    == ApplicationMode::OnlineRunning
                ? runtime_mode_service_.onlineLogicMonitorService().lastError()
                : runtime_mode_service_.simulationError();
            if (!error.message.empty())
            {
                message += QStringLiteral(": ") + fromUtf8(error.message);
            }
        }
        statusBar()->showMessage(message, 5000);
        return;
    }
    updateModeUi(tr("已进入%1").arg(modeText(runtime_mode_service_.mode())));
}

void MainWindow::updateModeUi(const QString &message)
{
    // 按服务层策略统一启用/禁用编辑入口，避免单个按钮遗漏状态同步
    const ApplicationMode mode = runtime_mode_service_.mode();
    const ModePolicy policy = runtime_mode_service_.policy();
    restoreCurrentModeAction();
    const bool running = mode != ApplicationMode::Editing;
    if (running)
    {
        if (hmi_navigation_service_->currentPageId().empty())
        {
            const HmiNavigationResult navigation = hmi_navigation_service_->start();
            if (!navigation.succeeded)
            {
                statusBar()->showMessage(fromUtf8(navigation.message), 5000);
            }
        }
        runtime_panel_controller_->enterRuntime(
            hmi_navigation_service_->currentPageId(),
            current_logic_id_,
            mode,
            runtime_mode_service_.plcConnectionState());
    }
    else
    {
        hmi_navigation_service_->stop();
        runtime_panel_controller_->leaveRuntime(
            mode, runtime_mode_service_.plcConnectionState());
    }
    // 将同一份模式策略同步到所有可编辑入口，避免只禁用部分操作
    ui_->projectDock->setEnabled(policy.allowsProjectEditing);
    ui_->propertiesDock->setEnabled(policy.allowsProjectEditing);
    hmi_editor_widget_->setEditingEnabled(policy.allowsProjectEditing);
    hmi_editor_widget_->setRuntimeActive(
        policy.usesVirtualRegisters || policy.usesPlcRegisters);
    logic_editor_widget_->setEditingEnabled(policy.allowsProjectEditing);
    if (mode == ApplicationMode::Editing)
    {
        alarm_service_.reset();
        logic_editor_widget_->clearRuntimeTrace();
    }
    ui_->hmiToolBar->setEnabled(policy.allowsProjectEditing);
    ui_->logicToolBar->setEnabled(policy.allowsProjectEditing);
    ui_->addButtonAction->setEnabled(policy.allowsProjectEditing);
    ui_->addIndicatorAction->setEnabled(policy.allowsProjectEditing);
    ui_->addNumericDisplayAction->setEnabled(policy.allowsProjectEditing);
    ui_->addNumericInputAction->setEnabled(policy.allowsProjectEditing);
    ui_->addLabelAction->setEnabled(policy.allowsProjectEditing);
    ui_->addPageJumpAction->setEnabled(policy.allowsProjectEditing);
    ui_->addAlarmListAction->setEnabled(policy.allowsProjectEditing);
    ui_->configureAlarmsAction->setEnabled(policy.allowsProjectEditing);
    ui_->configureRegisterCommentsAction->setEnabled(policy.allowsProjectEditing);
    ui_->deleteControlAction->setEnabled(policy.allowsProjectEditing);
    ui_->addNormallyOpenAction->setEnabled(policy.allowsProjectEditing);
    ui_->addNormallyClosedAction->setEnabled(policy.allowsProjectEditing);
    ui_->addRisingEdgeAction->setEnabled(policy.allowsProjectEditing);
    ui_->addFallingEdgeAction->setEnabled(policy.allowsProjectEditing);
    ui_->addNormalCoilAction->setEnabled(policy.allowsProjectEditing);
    ui_->addSetCoilAction->setEnabled(policy.allowsProjectEditing);
    ui_->addResetCoilAction->setEnabled(policy.allowsProjectEditing);
    ui_->addMoveAction->setEnabled(policy.allowsProjectEditing);
    ui_->addAddAction->setEnabled(policy.allowsProjectEditing);
    ui_->addSubAction->setEnabled(policy.allowsProjectEditing);
    ui_->addCompareAction->setEnabled(policy.allowsProjectEditing);
    ui_->editRungCommentAction->setEnabled(policy.allowsProjectEditing);
    ui_->deleteLogicAction->setEnabled(policy.allowsProjectEditing);
    ui_->newProjectAction->setEnabled(policy.allowsProjectEditing);
    ui_->saveProjectAction->setEnabled(policy.allowsProjectEditing);
    ui_->saveAsProjectAction->setEnabled(policy.allowsProjectEditing);
    ui_->loadProjectAction->setEnabled(policy.allowsProjectEditing);
    updateProjectTreeActions();
    updateEditActions();

    mode_status_label_->setText(modeText(mode));
    if (mode == ApplicationMode::Editing)
    {
        mode_status_label_->setStyleSheet(QStringLiteral(
            "border: 1px solid #75a58a; background: #e3f0e8; color: #205c3b; padding: 2px 8px;"));
    }
    else if (mode == ApplicationMode::OfflineRunning)
    {
        mode_status_label_->setStyleSheet(QStringLiteral(
            "border: 1px solid #bd8739; background: #fff0d2; color: #744b0e; padding: 2px 8px;"));
    }
    else
    {
        mode_status_label_->setStyleSheet(QStringLiteral(
            "border: 1px solid #4b88a8; background: #deeff7; color: #174f6c; padding: 2px 8px;"));
    }
    register_status_label_->setText(
        policy.usesVirtualRegisters ? tr("数据源：虚拟 M/D")
        : policy.usesPlcRegisters ? tr("数据源：PLC 缓存") : tr("数据源：未启用"));
    const PlcConnectionState plc_state = runtime_mode_service_.plcConnectionState();
    const bool plc_configuration_available = plc_state == PlcConnectionState::Disconnected
        || plc_state == PlcConnectionState::Faulted;
    ui_->configurePlcAction->setEnabled(
        policy.allowsProjectEditing && plc_configuration_available);
    ui_->configurePlcAction->setText(
        plc_state == PlcConnectionState::Faulted ? tr("PLC 重新配置") : tr("PLC 配置"));
    ui_->configurePlcAction->setToolTip(
        plc_state == PlcConnectionState::Faulted
            ? tr("清理故障会话后重新配置并连接真实 PLC")
            : tr("配置参数并连接真实 PLC"));
    ui_->disconnectPlcAction->setEnabled(plc_state != PlcConnectionState::Disconnected);
    if (plc_state == PlcConnectionState::Connecting)
    {
        register_status_label_->setText(tr("PLC：正在连接"));
    }
    else if (plc_state == PlcConnectionState::Connected)
    {
        register_status_label_->setText(
            runtime_mode_service_.initialPlcReadCompleted()
                ? tr("PLC：已连接，首读完成") : tr("PLC：已连接，正在首读"));
    }
    else if (plc_state == PlcConnectionState::Recovering)
    {
        register_status_label_->setText(tr("PLC：通信已恢复，正在重新首读"));
    }
    else if (plc_state == PlcConnectionState::Faulted)
    {
        register_status_label_->setText(tr("PLC：通信故障"));
    }
    updateSimulationUi(false);
    statusBar()->showMessage(message, 4000);
    const bool duplicate = ui_->outputList->count() > 0
        && ui_->outputList->item(ui_->outputList->count() - 1)->text() == message;
    if (!duplicate)
    {
        appendOutputMessage(message);
    }
}

void MainWindow::updateSimulationUi(bool report_fault)
{
    runtime_panel_controller_->updateSimulationUi(report_fault);
}

// 根据当前真实运行模式，同步更新模式工具栏单选按钮选中状态
void MainWindow::restoreCurrentModeAction()
{
    ui_->editingModeAction->setChecked(runtime_mode_service_.mode()
                                       == ApplicationMode::Editing);
    ui_->offlineModeAction->setChecked(runtime_mode_service_.mode()
                                       == ApplicationMode::OfflineRunning);
    ui_->onlineModeAction->setChecked(runtime_mode_service_.mode()
                                      == ApplicationMode::OnlineRunning);
}