#include "ParkingSpaceGuidePresenter.h"

#include <algorithm>
#include <cmath>
#include <chrono>
#include <cstring>
#include <exception>
#include <fstream>
#include <limits>

#include <QCollator>
#include <QCoreApplication>
#include <QDateTime>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QHostAddress>
#include <QImageReader>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QMetaObject>
#include <QNetworkInterface>
#include <QProcess>
#include <QStringList>
#include <QAbstractSocket>
#include <QPainter>
#include <QPen>
#include <QStorageInfo>
#include <QThread>
#include <QUuid>

#include <opencv2/imgproc.hpp>

#include "DetectPresenter.h"
#include "FixedRoiAutoExposureSession.h"
#include "GpioInput.h"
#include "GuideRecordStore.h"
#include "IVrFFMediaPusher.h"
#include "IYUDPClient.h"
#include "LaserDataLoader.h"
#include "ParkingStatusHttpServer.h"
#include "ParkingSpaceGuideRemoteServer.h"
#include "PathManager.h"
#include "Version.h"
#include "VrLog.h"

namespace {

constexpr int kMvsPixelTypeMono8 = 0x01080001;
constexpr int kMvsPixelTypeRGB8 = 0x02180014;
constexpr int kMvsPixelTypeBGR8 = 0x02180015;
constexpr int kMvsAcqModeContinuous = 2;
constexpr int kAirplaneProbeIntervalMs = 1000;
constexpr unsigned int kModelCaptureTimeoutMs = 1000;
constexpr unsigned int kVideoCaptureTimeoutMs = 1000;
constexpr int kVideoReconnectIntervalMs = 3000;
constexpr int kOfficialCameraMaxFps = 10;
constexpr int kOfficialVideoMaxFps = 8;
constexpr int kOfficialVideoMinIntervalMs = 125;
constexpr int kAutoExposureMinIntervalMs = 500;
constexpr int kDeviceWatchdogIntervalMs = 1000;
constexpr int kDeviceReconnectIntervalMs = 15000;
constexpr int kCameraRediscoverIntervalMs = 3000;
constexpr int kDevicePingTimeoutMs = 1000;
constexpr int kDevicePingFailCount = 2;
constexpr int kDeviceErrorMultiple = 2200;
constexpr int kDeviceErrorLidar = 2201;
constexpr int kDeviceErrorCamera = 2202;
constexpr int kDeviceErrorStorage = 2203;
constexpr int kDeviceErrorNetwork = 2204;
constexpr int kDeviceErrorEmergency = 2205;

void SortPathsNaturally(std::vector<QString>& paths)
{
    QCollator collator;
    collator.setCaseSensitivity(Qt::CaseInsensitive);
    collator.setNumericMode(true);
    std::sort(paths.begin(), paths.end(), [&collator](const QString& lhs,
                                                       const QString& rhs) {
        return collator.compare(QFileInfo(lhs).fileName(),
                                QFileInfo(rhs).fileName()) < 0;
    });
}

QString ConfigText(const std::string& value, const QString& fallback)
{
    const QString text = QString::fromStdString(value).trimmed();
    return text.isEmpty() ? fallback : text;
}

QString ResultText(const QString& value, const QString& fallback)
{
    const QString text = value.trimmed();
    return text.isEmpty() ? fallback : text;
}

QString FormatLocalDateTime(qint64 epochMs)
{
    if (epochMs <= 0) {
        return QString();
    }
    return QDateTime::fromMSecsSinceEpoch(epochMs).toString(
        QStringLiteral("yyyy-MM-dd HH:mm:ss"));
}

long long SteadyClockMs()
{
    return std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::steady_clock::now().time_since_epoch()).count();
}

bool IsPingableIpv4(const QString& address)
{
    const QString text = address.trimmed();
    if (text.isEmpty()) {
        return false;
    }
    const QHostAddress host(text);
    if (host.isNull() ||
        host.protocol() != QAbstractSocket::IPv4Protocol ||
        host.isLoopback() ||
        host.isMulticast() ||
        host == QHostAddress(QHostAddress::AnyIPv4) ||
        host == QHostAddress(QHostAddress::Broadcast)) {
        return false;
    }
    return true;
}

bool PingIpv4(const QString& address, int timeoutMs)
{
    if (!IsPingableIpv4(address)) {
        return false;
    }

    QStringList arguments;
#ifdef Q_OS_WIN
    arguments << QStringLiteral("-n") << QStringLiteral("1")
              << QStringLiteral("-w") << QString::number((std::max)(200, timeoutMs))
              << address;
#else
    const int timeoutSec = (std::max)(1, (timeoutMs + 999) / 1000);
    arguments << QStringLiteral("-c") << QStringLiteral("1")
              << QStringLiteral("-W") << QString::number(timeoutSec)
              << address;
#endif

    QProcess process;
    process.setProcessChannelMode(QProcess::SeparateChannels);
    process.start(QStringLiteral("ping"), arguments);
    if (!process.waitForStarted(500)) {
        return false;
    }
    if (!process.waitForFinished(timeoutMs + 800)) {
        process.kill();
        process.waitForFinished(200);
        return false;
    }
    return process.exitStatus() == QProcess::NormalExit &&
           process.exitCode() == 0;
}

cv::Rect NormalizedExposureRoi(const MvsCameraConfig& config,
                               int imageWidth,
                               int imageHeight)
{
    // 配置为 0~1 归一化区域，运行时按当前分辨率换成像素矩形。
    const double nx = std::clamp(config.exposureRoiX, 0.0, 1.0);
    const double ny = std::clamp(config.exposureRoiY, 0.0, 1.0);
    double nw = config.exposureRoiWidth;
    double nh = config.exposureRoiHeight;
    if (nw <= 0.0) {
        nw = 1.0 - nx;
    }
    if (nh <= 0.0) {
        nh = 1.0 - ny;
    }
    nw = std::clamp(nw, 0.0, 1.0 - nx);
    nh = std::clamp(nh, 0.0, 1.0 - ny);

    int roiX = static_cast<int>(std::lround(nx * imageWidth));
    int roiY = static_cast<int>(std::lround(ny * imageHeight));
    int roiWidth = static_cast<int>(std::lround(nw * imageWidth));
    int roiHeight = static_cast<int>(std::lround(nh * imageHeight));
    roiX = std::clamp(roiX, 0, (std::max)(0, imageWidth - 3));
    roiY = std::clamp(roiY, 0, (std::max)(0, imageHeight - 3));
    roiWidth = std::clamp(roiWidth, 3, (std::max)(3, imageWidth - roiX));
    roiHeight = std::clamp(roiHeight, 3, (std::max)(3, imageHeight - roiY));
    return cv::Rect(roiX, roiY, roiWidth, roiHeight);
}

int OfficialVideoFps(int configuredFps)
{
    int fps = configuredFps;
    if (fps < 1) {
        fps = 5;
    }
    if (fps > kOfficialVideoMaxFps) {
        fps = kOfficialVideoMaxFps;
    }
    return fps;
}

double OfficialCameraFrameRate(double configuredRate, int videoFps)
{
    double rate = configuredRate;
    if (!std::isfinite(rate) || rate <= 0.0) {
        rate = static_cast<double>(kOfficialCameraMaxFps);
    }
    rate = (std::min)(rate, static_cast<double>(kOfficialCameraMaxFps));
    if (videoFps > 0) {
        rate = (std::min)(rate, static_cast<double>(videoFps));
    }
    if (rate < 1.0) {
        rate = 1.0;
    }
    return rate;
}

ParkingSpaceGuideInfo FallbackGuideInfo(const UdpBroadcastConfig& config)
{
    ParkingSpaceGuideInfo info;
    info.targetId = ConfigText(config.targetId, QStringLiteral("T001"));
    info.parkId = ConfigText(config.parkId, QStringLiteral("P01"));
    info.modelType = QStringLiteral("未知");
    return info;
}

QString NormalizeSelectedModelType(const QString& value,
                                   const AircraftModelsConfig& models)
{
    const QString modelType = NormalizedAircraftName(value);
    if (modelType.isEmpty()) {
        return QString();
    }
    return models.IsSelectable(modelType) ? modelType : QString();
}

bool MustPreserveGuideState(int guideStateCode)
{
    const ParkingGuideState state =
        ParkingGuideStateFromCode(guideStateCode);
    return state == ParkingGuideState::Overshot;
}

bool IsLedVisibleGuideState(int guideStateCode)
{
    switch (ParkingGuideStateFromCode(guideStateCode)) {
    case ParkingGuideState::DockingStarted:
    case ParkingGuideState::Capturing:
    case ParkingGuideState::CenterLineAligned:
    case ParkingGuideState::Slow:
    case ParkingGuideState::AzimuthGuidance:
    case ParkingGuideState::StopPositionReached:
    case ParkingGuideState::DockingCompleted:
    case ParkingGuideState::Overshot:
    case ParkingGuideState::AircraftVerificationFailed:
    case ParkingGuideState::GateBlocked:
    case ParkingGuideState::ViewBlocked:
    case ParkingGuideState::EmergencyStop:
    case ParkingGuideState::ChocksOn:
    case ParkingGuideState::SystemError:
        return true;
    default:
        return false;
    }
}

bool SameEmergencyStopConfig(const EmergencyStopConfig& lhs,
                             const EmergencyStopConfig& rhs)
{
    return lhs.enabled == rhs.enabled &&
           lhs.directionPath == rhs.directionPath &&
           lhs.valuePath == rhs.valuePath &&
           lhs.pollIntervalMs == rhs.pollIntervalMs &&
           lhs.debounceMs == rhs.debounceMs &&
           lhs.reconnectIntervalMs == rhs.reconnectIntervalMs;
}

bool SameRemoteViewConfig(const RemoteViewConfig& lhs,
                          const RemoteViewConfig& rhs)
{
    return lhs.enabled == rhs.enabled &&
           lhs.discoveryPort == rhs.discoveryPort &&
           lhs.controlPort == rhs.controlPort &&
           lhs.publishPort == rhs.publishPort &&
           lhs.topic == rhs.topic;
}

bool IsExceptionGuideState(int guideStateCode)
{
    switch (guideStateCode) {
    case 10:
    case 11:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 22:
    case 23:
    case 24:
        return true;
    default:
        return false;
    }
}

QJsonObject BuildGuideInfoJson(const ParkingSpaceGuideInfo& info,
                               const UdpBroadcastConfig& config)
{
    const ParkingSpaceGuideInfo fallback = FallbackGuideInfo(config);

    QJsonObject object;
    object["targetId"] = ResultText(info.targetId, fallback.targetId);
    object["parkId"] = ResultText(info.parkId, fallback.parkId);
    object["expectedModelType"] = info.expectedModelType.trimmed();
    object["modelType"] = ResultText(info.modelType, fallback.modelType);
    object["modelMatched"] = info.modelMatched;
    object["guideStateCode"] = info.guideStateCode;
    object["distanceToStop"] = info.distance;
    object["bodyYawAngle"] = info.angle;
    object["lateralOffset"] = info.lateralOffset;
    object["aircraftSpeed"] = info.aircraftSpeed;
    object["hasException"] = info.hasException || IsExceptionGuideState(info.guideStateCode);
    object["guideText"] = info.guideText;
    // 轮挡时间对外使用本地日期时间，未记录为空字符串。
    object["personChockTime"] = FormatLocalDateTime(info.personChockTime);
    object["chockOnTime"] = FormatLocalDateTime(info.chockOnTime);
    object["chockOffTime"] = FormatLocalDateTime(info.chockOffTime);
    return object;
}

QJsonObject BuildDetectionResultPayload(const DetectionResult& result,
                                        const UdpBroadcastConfig& config)
{
    const bool hasResult = !result.parkingSpaceInfoList.empty();
    const bool success = result.errorCode == 0 && hasResult;
    const ParkingSpaceGuideInfo firstInfo = hasResult
        ? result.parkingSpaceInfoList.front()
        : FallbackGuideInfo(config);
    const QJsonObject firstResult = BuildGuideInfoJson(firstInfo, config);

    QJsonObject payload = firstResult;
    payload["protocol"] = QStringLiteral("ParkingSpaceGuideResult");
    payload["version"] = QStringLiteral("1.1");
    payload["success"] = success;
    payload["hasResult"] = hasResult;
    payload["hasException"] = result.errorCode != 0 || firstResult["hasException"].toBool();
    payload["message"] = result.message;
    payload["errorCode"] = result.errorCode;
    payload["timestamp"] = QDateTime::currentMSecsSinceEpoch();
    return payload;
}

QImage DrawPersonDetectionOverlay(const QImage& frame,
                                  const PersonDetectionResult& detection)
{
    if (frame.isNull()) {
        return QImage();
    }

    QImage annotated = frame.convertToFormat(QImage::Format_RGB888);
    QPainter painter(&annotated);
    painter.setRenderHint(QPainter::Antialiasing, true);

    QPen roiPen(QColor(255, 215, 0));
    roiPen.setWidth(4);
    painter.setPen(roiPen);
    painter.drawRect(detection.roi);

    for (const QRectF& box : detection.personBoxes) {
        const QPointF groundPoint(box.center().x(), box.bottom());
        const bool insideRoi =
            groundPoint.x() >= detection.roi.left() &&
            groundPoint.x() <= detection.roi.right() &&
            groundPoint.y() >= detection.roi.top() &&
            groundPoint.y() <= detection.roi.bottom();
        QPen boxPen(insideRoi
                        ? QColor(0, 220, 80)
                        : QColor(230, 60, 60));
        boxPen.setWidth(4);
        painter.setPen(boxPen);
        painter.drawRect(box);
        painter.drawEllipse(groundPoint, 5.0, 5.0);
    }
    return annotated;
}

QImage DrawModelRecognitionRoi(const QImage& frame, const QRect& roi)
{
    if (frame.isNull() || !roi.isValid() || roi.isEmpty()) {
        return frame;
    }

    QImage annotated = frame.convertToFormat(QImage::Format_RGB888);
    QPainter painter(&annotated);
    painter.setRenderHint(QPainter::Antialiasing, true);

    const int penWidth = (std::max)(
        4, (std::min)(annotated.width(), annotated.height()) / 300);
    QPen roiPen(QColor(255, 215, 0));
    roiPen.setWidth(penWidth);
    painter.setPen(roiPen);

    // Keep the complete stroke inside the image. This also makes a full-frame
    // ROI visible instead of losing half of its border outside the canvas.
    const int inset = (penWidth + 1) / 2;
    QRect visibleRoi = roi.intersected(annotated.rect());
    visibleRoi.setLeft((std::max)(visibleRoi.left(), inset));
    visibleRoi.setTop((std::max)(visibleRoi.top(), inset));
    visibleRoi.setRight((std::min)(visibleRoi.right(),
                                  annotated.width() - 1 - inset));
    visibleRoi.setBottom((std::min)(visibleRoi.bottom(),
                                   annotated.height() - 1 - inset));
    if (visibleRoi.isValid() && !visibleRoi.isEmpty()) {
        painter.drawRect(visibleRoi);
    }
    return annotated;
}

bool CropNormalizedRoi(const QImage& source,
                       double roiX,
                       double roiY,
                       double roiWidth,
                       double roiHeight,
                       QImage& cropped,
                       QString& errorMessage,
                       QRect* sourceRoi = nullptr)
{
    cropped = QImage();
    if (source.isNull() || source.width() <= 0 || source.height() <= 0) {
        errorMessage = QStringLiteral("检测原始图像无效");
        return false;
    }

    const double x = std::clamp(roiX, 0.0, 1.0);
    const double y = std::clamp(roiY, 0.0, 1.0);
    const double width = std::clamp(roiWidth, 0.0, 1.0 - x);
    const double height = std::clamp(roiHeight, 0.0, 1.0 - y);
    const int left = std::clamp(
        static_cast<int>(std::floor(x * source.width())),
        0,
        source.width() - 1);
    const int top = std::clamp(
        static_cast<int>(std::floor(y * source.height())),
        0,
        source.height() - 1);
    const int right = std::clamp(
        static_cast<int>(std::ceil((x + width) * source.width())),
        left + 1,
        source.width());
    const int bottom = std::clamp(
        static_cast<int>(std::ceil((y + height) * source.height())),
        top + 1,
        source.height());
    const QRect roi(left, top, right - left, bottom - top);
    if (!roi.isValid() || roi.width() <= 0 || roi.height() <= 0) {
        errorMessage = QStringLiteral("检测区域无效");
        return false;
    }

    cropped = source.copy(roi);
    if (cropped.isNull()) {
        errorMessage = QStringLiteral("裁剪检测区域失败");
        return false;
    }
    if (sourceRoi) {
        *sourceRoi = roi;
    }
    return true;
}

bool SaveAircraftRecognitionDebugImage(const QImage& roiImage,
                                       const VrDebugParam& debugParam,
                                       int attempt,
                                       QString& savedPath,
                                       QString& errorMessage)
{
    savedPath.clear();
    errorMessage.clear();
    if (roiImage.isNull()) {
        errorMessage = QStringLiteral("飞机识别ROI图像无效");
        return false;
    }

    const QString debugRoot = debugParam.debugOutputPath.empty()
        ? QCoreApplication::applicationDirPath() + QStringLiteral("/debug")
        : QString::fromStdString(debugParam.debugOutputPath);
    QDir outputDir(QDir(debugRoot).filePath(
        QStringLiteral("aircraft_recognition")));
    if (!outputDir.exists() && !outputDir.mkpath(QStringLiteral("."))) {
        errorMessage = QStringLiteral("无法创建飞机识别调试图像目录：%1")
                           .arg(outputDir.absolutePath());
        return false;
    }

    static std::atomic<unsigned long long> imageSequence{0};
    const QString fileName = QStringLiteral("aircraft_roi_%1_attempt%2_%3.png")
        .arg(QDateTime::currentDateTime().toString(
            QStringLiteral("yyyyMMdd_HHmmss_zzz")))
        .arg((std::max)(1, attempt))
        .arg(imageSequence.fetch_add(1));
    savedPath = outputDir.filePath(fileName);
    if (!roiImage.save(savedPath, "PNG")) {
        errorMessage = QStringLiteral("保存飞机识别调试图像失败：%1")
                           .arg(savedPath);
        savedPath.clear();
        return false;
    }
    return true;
}

class ModelRecognitionResultApplyGuard
{
public:
    ModelRecognitionResultApplyGuard(std::atomic<bool>& applying,
                                     std::condition_variable& condition)
        : m_applying(applying),
          m_condition(condition)
    {
    }

    ~ModelRecognitionResultApplyGuard()
    {
        if (m_active) {
            m_applying.store(false);
            m_condition.notify_all();
        }
    }

    void Activate()
    {
        m_active = true;
    }

private:
    std::atomic<bool>& m_applying;
    std::condition_variable& m_condition;
    bool m_active = false;
};

} // namespace

ParkingSpaceGuidePresenter::ParkingSpaceGuidePresenter(QObject* parent)
    : ParkingSpaceGuidePresenter(ParkingSpaceGuideSimulationOptions(), parent)
{
}

qint64 MonotonicMilliseconds()
{
    return std::chrono::duration_cast<std::chrono::milliseconds>(
               std::chrono::steady_clock::now().time_since_epoch())
        .count();
}

ParkingSpaceGuidePresenter::ParkingSpaceGuidePresenter(
    const ParkingSpaceGuideSimulationOptions& simulationOptions,
    QObject* parent)
    : QObject(parent)
    , m_simulationOptions(simulationOptions)
{
    m_simulationOptions.frameIntervalMs =
        (std::max)(1, m_simulationOptions.frameIntervalMs);
}

ParkingSpaceGuidePresenter::~ParkingSpaceGuidePresenter()
{
    DeinitApp();
}

int ParkingSpaceGuidePresenter::Init()
{
    if (m_shutdownRequested.load()) {
        return -1;
    }
    m_reconfiguring.store(false);
    NotifyWorkStatus(WorkStatus::InitIng);
    NotifyStatus("停机引导初始化中");

    int ret = InitConfig();
    if (ret != 0) {
        NotifyWorkStatus(WorkStatus::Error);
        return ret;
    }
    if (m_shutdownRequested.load()) {
        return -1;
    }

    // 记录库连不上时引导仍可继续，因此这里不把失败当作初始化失败。
    InitGuideRecordStore();

    const ConfigResult config = m_configManager->GetConfigResult();
    m_emergencyStopIgnored.store(config.debugParam.enableDebug);
    LOG_INFO("[ParkingSpaceGuide][Algorithm] debug enableDebug=%d printDetailLog=%d\n",
             config.debugParam.enableDebug ? 1 : 0,
             config.debugParam.printDetailLog ? 1 : 0);
    m_cameraList.clear();

    DetectionResult initialStatus;
    initialStatus.errorCode = -1;
    initialStatus.message = QStringLiteral("无有效结果");
    UpdateCurrentStatus(initialStatus);

    m_detectPresenter = new DetectPresenter();

    if (m_simulationOptions.enabled) {
        ret = InitSimulationData();
        if (ret != 0) {
            NotifyWorkStatus(WorkStatus::Error);
            return ret;
        }
        if (m_shutdownRequested.load()) {
            return -1;
        }
    } else {
        ret = InitMvsCamera(config.mvsCamera);
        if (ret != 0) {
            NotifyStatus("平面相机初始化失败，继续使用预留算法模式");
        }
        if (m_cameraList.empty()) {
            const std::string cameraName = config.mvsCamera.serialNumber.empty()
                ? std::string("相机")
                : config.mvsCamera.serialNumber;
            m_cameraList.push_back(std::make_pair(cameraName, static_cast<void*>(m_mvsDevice)));
        }
        if (m_shutdownRequested.load()) {
            return -1;
        }

        ret = InitRsLidar(config.lidarEnabled, config.lidarConfig);
        if (ret != 0) {
            NotifyStatus("雷达初始化失败，继续使用预留算法模式");
        }
        if (m_shutdownRequested.load()) {
            return -1;
        }
    }

    ret = InitLedDisplay(config.ledDisplayConfig);
    if (ret != 0) {
        NotifyStatus("显示屏初始化失败");
    }
    if (m_shutdownRequested.load()) {
        return -1;
    }

    ret = InitUdpBroadcast(config.udpBroadcastConfig);
    if (ret != 0) {
        NotifyStatus("组播初始化失败");
    }
    if (m_shutdownRequested.load()) {
        return -1;
    }

    ret = InitHttpServer(config.httpServerConfig);
    if (ret != 0) {
        NotifyStatus("HTTP状态服务初始化失败");
    }
    if (m_shutdownRequested.load()) {
        return -1;
    }

    ret = InitEmergencyStop(config.emergencyStopConfig);
    if (ret != 0) {
        NotifyStatus("急停输入当前不可用，检测已被安全联锁阻止");
    }
    if (m_shutdownRequested.load()) {
        return -1;
    }

    if (StatusCallback()) {
        StatusCallback()->OnCameraCountChanged(1);
    }

    m_initialized = true;
    if (m_shutdownRequested.load()) {
        m_initialized.store(false);
        return -1;
    }
    ret = InitRemoteView(config.remoteViewConfig);
    if (ret != 0) {
        NotifyStatus("远程显示服务初始化失败，不影响本机停机引导");
    }
    const SelfCheckResult bootCheck = RunSelfCheck();
    {
        std::lock_guard<std::mutex> recordLock(m_recordMutex);
        m_lastSelfCheck = bootCheck;
        m_hasCompletedSelfCheck = true;
    }
    RecordGuideEvent(QStringLiteral("boot_self_check"), bootCheck.message);
    NotifyStatus(bootCheck.ok
        ? "开机自检通过"
        : bootCheck.message.toUtf8().toStdString());
    // 开机自检失败同样切到系统错误，不能被 WAIT 覆盖。
    if (!bootCheck.ok) {
        RejectStartForSelfCheck(bootCheck);
    } else {
        PublishCurrentSafetyState(true, false);
    }
    NotifyStatus("停机引导初始化完成");
    // 正式工作：初始化完成后打开实时视频，直到软件退出再关。
    StartOfficialVideoStreamIfNeeded();
    StartDeviceWatchdog();
    return 0;
}

void ParkingSpaceGuidePresenter::RequestShutdown()
{
    m_shutdownRequested.store(true);
    m_initialized.store(false);
    m_reconfiguring.store(true);
    m_stopDetectionRequested.store(true);
    m_detectionCondition.notify_all();
    RequestVideoStreamStop();
    m_deviceWatchdogStop.store(true);
    m_deviceWatchdogCondition.notify_all();
}

void ParkingSpaceGuidePresenter::DeinitApp()
{
    if (m_deinitStarted.exchange(true)) {
        return;
    }

    RequestShutdown();
    LOG_INFO("[ParkingSpaceGuide][Shutdown] DeviceWatchdog stop begin\n");
    StopDeviceWatchdog();
    LOG_INFO("[ParkingSpaceGuide][Shutdown] DeviceWatchdog stop complete\n");
    {
        std::lock_guard<std::mutex> reconfigurationLock(m_reconfigurationMutex);
        m_reconfiguring.store(true);
        // 先停远程控制，避免 ZeroMQ 回调线程在后续 StopDetection/关库时仍进入业务。
        LOG_INFO("[ParkingSpaceGuide][Shutdown] CloseRemoteView begin\n");
        CloseRemoteView();
        LOG_INFO("[ParkingSpaceGuide][Shutdown] CloseRemoteView complete\n");
        LOG_INFO("[ParkingSpaceGuide][Shutdown] StopDetection begin\n");
        StopDetection();
        LOG_INFO("[ParkingSpaceGuide][Shutdown] StopDetection complete\n");
        LOG_INFO("[ParkingSpaceGuide][Shutdown] CloseGuideRecordStore begin\n");
        CloseGuideRecordStore();
        LOG_INFO("[ParkingSpaceGuide][Shutdown] CloseGuideRecordStore complete\n");
        LOG_INFO("[ParkingSpaceGuide][Shutdown] CloseDevices begin\n");
        CloseDevices();
        LOG_INFO("[ParkingSpaceGuide][Shutdown] CloseDevices complete\n");

        LOG_INFO("[ParkingSpaceGuide][Shutdown] DetectPresenter delete begin\n");
        delete m_detectPresenter;
        m_detectPresenter = nullptr;
        LOG_INFO("[ParkingSpaceGuide][Shutdown] DetectPresenter delete complete\n");
    }

    if (m_configManager) {
        LOG_INFO("[ParkingSpaceGuide][Shutdown] ConfigManager shutdown begin\n");
        m_configManager->Shutdown();
        LOG_INFO("[ParkingSpaceGuide][Shutdown] ConfigManager shutdown complete\n");
        delete m_configManager;
        m_configManager = nullptr;
    }
    LOG_INFO("[ParkingSpaceGuide][Shutdown] DeinitApp complete\n");
}

bool ParkingSpaceGuidePresenter::StartAutomaticDetection(int cameraIndex)
{
    return StartDetectionInternal(QString(), cameraIndex, true, true);
}

bool ParkingSpaceGuidePresenter::StartDetection(
    const QString& selectedModelType,
    int cameraIndex)
{
    return StartDetectionInternal(selectedModelType,
                                  cameraIndex,
                                  true,
                                  false);
}

bool ParkingSpaceGuidePresenter::SelectModel(
    const QString& selectedModelType)
{
    const QString normalizedModelType =
        NormalizeSelectedModelType(selectedModelType, CurrentAircraftModels());
    if (normalizedModelType.isEmpty()) {
        NotifyStatus("远程显示选择了无效机型");
        return false;
    }
    if (m_shutdownRequested.load() ||
        !m_initialized.load() || m_reconfiguring.load()) {
        NotifyStatus("系统未初始化，无法同步机型");
        return false;
    }

    {
        std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
        if (m_detectionRunning.load() &&
            m_selectedModelType.compare(normalizedModelType,
                                        Qt::CaseInsensitive) != 0) {
            NotifyStatus("停机引导运行中，无法切换机型");
            return false;
        }
        m_selectedModelType = normalizedModelType;
    }

    emit SelectedModelChanged(normalizedModelType);
    DetectionResult result = CreateGuideStateResult(
        ParkingGuideState::Waiting,
        QStringLiteral("WAIT"),
        QStringLiteral("已选择机型%1").arg(normalizedModelType),
        false);
    PublishDetectionResult(result);
    NotifyStatus(QStringLiteral("远程显示已选择机型：%1")
                     .arg(normalizedModelType)
                     .toUtf8()
                     .toStdString());
    return true;
}

bool ParkingSpaceGuidePresenter::StartDetectionInternal(
    const QString& selectedModelType,
    int cameraIndex,
    bool clearSafetyLatch,
    bool automaticMode)
{
    std::lock_guard<std::mutex> threadLock(m_detectionThreadMutex);
    if (m_shutdownRequested.load()) {
        return false;
    }
    const QString normalizedModelType =
        NormalizeSelectedModelType(selectedModelType, CurrentAircraftModels());
    if (!selectedModelType.trimmed().isEmpty() &&
        normalizedModelType.isEmpty()) {
        NotifyStatus("请选择配置文件中的有效机型");
        return false;
    }
    if (m_shutdownRequested.load() ||
        !m_initialized || m_reconfiguring.load() ||
        !m_detectPresenter || !m_configManager) {
        NotifyStatus("系统未初始化");
        return false;
    }
    {
        std::lock_guard<std::mutex> safetyLock(m_safetyMutex);
        if (!clearSafetyLatch && m_emergencyStopLatched.load()) {
            NotifyStatus("急停安全联锁已触发，配置重载不自动恢复停机引导");
            return false;
        }
        if (m_emergencyStopEnabled.load() &&
            m_emergencyStopActive.load()) {
            NotifyStatus("急停按钮处于按下状态，禁止启动停机引导");
            NotifyWorkStatus(WorkStatus::EmergencyStop);
            return false;
        }
        if (m_emergencyStopEnabled.load() &&
            !m_emergencyStopAvailable.load()) {
            NotifyStatus("急停输入不可用，禁止启动停机引导");
            NotifyWorkStatus(WorkStatus::Error);
            return false;
        }
    }
    if (m_simulationOptions.enabled &&
        (m_simulationRadarFrames.size() < 2 ||
         m_simulationCameraFrames.empty())) {
        NotifyStatus("多帧仿真点云或图像数据未就绪");
        return false;
    }
    const ConfigResult deviceConfig = m_configManager->GetConfigResult();
    if (!m_simulationOptions.enabled && HasRequiredDeviceOffline()) {
        ApplySystemErrorForOfflineDevice();
        return false;
    }
    if (!m_simulationOptions.enabled &&
        deviceConfig.lidarEnabled &&
        (!m_lidarDevice || !m_lidarDevice->IsRunning())) {
        NotifyStatus("雷达未连接，无法启动实时检测");
        return false;
    }

    if (m_detectionRunning.load()) {
        const bool activeAutomaticMode = m_automaticDetection.load();
        QString activeModelType;
        {
            std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
            activeModelType = m_selectedModelType;
        }
        if (activeAutomaticMode != automaticMode ||
            activeModelType.compare(normalizedModelType,
                                    Qt::CaseInsensitive) != 0) {
            NotifyStatus("当前引导会话机型与本次选择不一致");
            return false;
        }
        NotifyStatus(m_simulationOptions.enabled
            ? "停机引导仿真回放已在运行"
            : "停机引导实时检测已在运行");
        return true;
    }

    if (m_simulationThread.joinable()) {
        m_simulationThread.join();
    }
    if (m_detectionThread.joinable()) {
        m_detectionThread.join();
    }
    if (m_simulationOptions.enabled) {
        StopVideoStream();
    }
    WaitForModelRecognitionTask(true);

    if (cameraIndex > 0) {
        m_detectIndex = cameraIndex;
    } else {
        m_detectIndex = m_currentCameraIndex;
    }

    {
        std::lock_guard<std::mutex> dataLock(m_dataMutex);
        m_consumedCloudSequence = m_cloudSequence;
        m_processedCloudSequence = m_cloudSequence;
        m_lidarErrorPending = false;
        m_lidarErrorMessage.clear();
        if (m_simulationOptions.enabled &&
            !m_simulationRadarFrames.empty()) {
            m_latestCloudFrame = m_simulationRadarFrames.front();
        }
    }
    m_trackingMode.store(false);
    m_simulationRound.store(0);
    m_lastProbeAcceptedMs.store(0);
    // 上一轮停止/回放结束会留下停止标志；用户再次开始时先清掉，
    // 否则自检后会被误判为“安全状态已变化”。
    m_stopDetectionRequested.store(false);
    if (m_simulationOptions.enabled &&
        !m_simulationCameraFrames.empty()) {
        CacheSimulationCameraFrame(0, m_simulationCameraFrames.front());
    }
    {
        std::lock_guard<std::mutex> publishLock(m_publishMutex);
        m_lastDetectionResult = DetectionResult();
    }

    std::unique_lock<std::mutex> safetyPublishLock(m_safetyPublishMutex);
    {
        std::unique_lock<std::mutex> safetyLock(m_safetyMutex);
        if (m_shutdownRequested.load() ||
            !m_initialized || m_reconfiguring.load()) {
            NotifyStatus("系统正在重新配置，无法启动停机引导");
            return false;
        }
        if (m_emergencyStopEnabled.load() &&
            m_emergencyStopActive.load()) {
            NotifyStatus("急停按钮处于按下状态，禁止启动停机引导");
            NotifyWorkStatus(WorkStatus::EmergencyStop);
            return false;
        }
        if (m_emergencyStopEnabled.load() &&
            !m_emergencyStopAvailable.load()) {
            NotifyStatus("急停输入不可用，禁止启动停机引导");
            NotifyWorkStatus(WorkStatus::Error);
            return false;
        }

        if (!clearSafetyLatch && m_emergencyStopLatched.load()) {
            NotifyStatus("急停安全联锁已触发，配置重载不自动恢复停机引导");
            return false;
        }

        if (clearSafetyLatch) {
            m_emergencyStopLatched.store(false);
        }
        {
            std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
            m_selectedModelType = normalizedModelType;
        }
        if (!normalizedModelType.isEmpty()) {
            emit SelectedModelChanged(normalizedModelType);
        }

        // 激活前自检：雷达、相机、存储、网络，任一项失败则终止启动。
        m_selfCheckRunning.store(true);
        safetyLock.unlock();
        DetectionResult checkingResult = CreateGuideStateResult(
            ParkingGuideState::Waiting,
            QStringLiteral("CHECK"),
            QStringLiteral("系统自检中"),
            false);
        PublishDetectionResult(checkingResult);
        const SelfCheckResult selfCheck = RunSelfCheck();
        {
            std::lock_guard<std::mutex> recordLock(m_recordMutex);
            m_lastSelfCheck = selfCheck;
            m_hasCompletedSelfCheck = true;
        }
        m_selfCheckRunning.store(false);
        RecordGuideEvent(QStringLiteral("self_check"), selfCheck.message);
        if (!selfCheck.ok) {
            m_activated.store(false);
            RejectStartForSelfCheck(selfCheck);
            return false;
        }

        safetyLock.lock();
        if (m_stopDetectionRequested.load() ||
            m_emergencyStopLatched.load() ||
            (m_emergencyStopEnabled.load() &&
             (!m_emergencyStopAvailable.load() ||
              m_emergencyStopActive.load()))) {
            NotifyStatus("安全状态已变化，停机引导启动已取消");
            m_activated.store(false);
            return false;
        }

        m_automaticDetection.store(automaticMode);
        m_stopDetectionRequested.store(false);
        m_detectionRunning.store(true);
        m_activated.store(true);
        safetyLock.unlock();
        BeginGuideSession();

        DetectionResult waitingResult = CreateGuideStateResult(
            ParkingGuideState::Waiting,
            QStringLiteral("WAIT"),
            automaticMode
                ? QStringLiteral("系统已激活，自动检测已启动，等待飞机进入引导范围")
                : normalizedModelType.isEmpty()
                    ? QStringLiteral("系统已激活，未选择机型，等待实际检测并进入100米引导范围")
                    : QStringLiteral("系统已激活，%1已选择，等待飞机进入100米引导范围")
                          .arg(normalizedModelType),
            false);
        PublishDetectionResult(waitingResult);
        if (m_stopDetectionRequested.load() ||
            m_emergencyStopLatched.load() ||
            (m_emergencyStopEnabled.load() &&
             (!m_emergencyStopAvailable.load() ||
              m_emergencyStopActive.load()))) {
            m_detectionRunning.store(false);
            m_automaticDetection.store(false);
            m_activated.store(false);
            {
                std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
                m_selectedModelType.clear();
            }
            FinishGuideSession(static_cast<int>(ParkingGuideState::Waiting),
                               true);
            NotifyStatus("安全状态已变化，停机引导启动已取消");
            return false;
        }

        NotifyWorkStatus(WorkStatus::Working);
        NotifyStatus(m_simulationOptions.enabled
            ? (automaticMode
                   ? "停机引导自动仿真检测正在启动"
                   : "停机引导多帧仿真回放正在启动")
            : (automaticMode
                   ? "停机引导自动实时检测正在启动"
                   : "停机引导实时检测正在启动"));
        try {
            m_detectionThread = std::thread(
                &ParkingSpaceGuidePresenter::DetectionLoop,
                this,
                normalizedModelType,
                automaticMode);
            if (m_simulationOptions.enabled) {
                m_simulationThread = std::thread(
                    &ParkingSpaceGuidePresenter::SimulationPlaybackLoop, this);
            }
        } catch (...) {
            m_stopDetectionRequested.store(true);
            m_detectionRunning.store(false);
            m_automaticDetection.store(false);
            {
                std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
                m_selectedModelType.clear();
            }
            safetyPublishLock.unlock();
            m_detectionCondition.notify_all();
            if (m_simulationThread.joinable()) {
                m_simulationThread.join();
            }
            if (m_detectionThread.joinable()) {
                m_detectionThread.join();
            }
            NotifyWorkStatus(WorkStatus::Error);
            NotifyStatus(m_simulationOptions.enabled
                ? "启动停机引导仿真线程失败"
                : "启动停机引导实时检测线程失败");
            m_activated.store(false);
            FinishGuideSession(static_cast<int>(ParkingGuideState::SystemError),
                               true);
            return false;
        }
    }
    if (m_simulationOptions.enabled &&
        m_detectionRunning.load() &&
        !m_shutdownRequested.load()) {
        const ConfigResult streamConfig = m_configManager->GetConfigResult();
        StartVideoStream(streamConfig.httpFlvStreamConfig,
                         streamConfig.mvsCamera);
    }
    return true;
}

bool ParkingSpaceGuidePresenter::TriggerDetection(int cameraIndex)
{
    std::lock_guard<std::mutex> threadLock(m_detectionThreadMutex);
    if (m_shutdownRequested.load() ||
        !m_initialized || m_reconfiguring.load() ||
        !m_detectPresenter || !m_configManager) {
        NotifyStatus("系统未初始化");
        return false;
    }

    {
        std::lock_guard<std::mutex> safetyLock(m_safetyMutex);
        if (m_emergencyStopLatched.load() ||
            (m_emergencyStopEnabled.load() &&
             (!m_emergencyStopAvailable.load() ||
              m_emergencyStopActive.load()))) {
            NotifyStatus("急停安全联锁未复位，请解除急停后点击开始");
            NotifyWorkStatus(m_emergencyStopActive.load()
                ? WorkStatus::EmergencyStop
                : WorkStatus::Error);
            return false;
        }
    }

    if (m_detectionRunning.load()) {
        NotifyStatus("实时检测运行中，无法执行单次检测");
        return false;
    }

    if (cameraIndex > 0) {
        m_detectIndex = cameraIndex;
    } else {
        m_detectIndex = m_currentCameraIndex;
    }

    std::shared_ptr<const OwnedCloudFrame> cloudFrame;
    {
        std::lock_guard<std::mutex> dataLock(m_dataMutex);
        cloudFrame = m_latestCloudFrame;
    }
    if (!cloudFrame) {
        NotifyStatus("暂无可用雷达点云");
        return false;
    }

    NotifyWorkStatus(WorkStatus::Detecting);
    NotifyStatus("停机引导单次检测已开始");
    bool success = false;
    ParkingGuideAlgorithmState algorithmState;
    try {
        success = DetectOnce(cloudFrame->cloud,
                             cloudFrame->timestampMs,
                             algorithmState);
    } catch (const std::exception& e) {
        NotifyStatus(std::string("停机引导单次检测异常：") + e.what());
    } catch (...) {
        NotifyStatus("停机引导单次检测发生未知异常");
    }
    if (m_emergencyStopLatched.load()) {
        NotifyWorkStatus(m_emergencyStopActive.load()
            ? WorkStatus::EmergencyStop
            : WorkStatus::Ready);
        return false;
    }
    NotifyWorkStatus(success ? WorkStatus::Completed : WorkStatus::Error);
    NotifyStatus(success ? "停机引导单次检测完成"
                         : "停机引导单次检测失败");
    return success;
}

bool ParkingSpaceGuidePresenter::DetectOnce(const RsCloudData& cloud,
                                            qint64 frameTimestampMs,
                                            ParkingGuideAlgorithmState& algorithmState)
{
    std::lock_guard<std::mutex> executionLock(m_detectionExecutionMutex);
    if (!m_detectPresenter || !m_configManager) {
        return false;
    }

    DetectionResult result;
    ParkingGuideAlgorithmControl control;
    ModelRecognitionResultApplyGuard modelResultApplyGuard(
        m_modelRecognitionResultApplying,
        m_detectionCondition);
    result.cameraIndex = m_detectIndex;
    const ConfigResult configResult = m_configManager->GetConfigResult();
    const bool printDetailLog = configResult.debugParam.printDetailLog;
    const VrAlgorithmParams algorithmParams =
        m_configManager->GetAlgorithmParams();
    algorithmState.stopDistanceCompensation =
        configResult.aircraftModels.StopDistanceCompensation(
            algorithmState.selectedModelType);
    size_t scanPointCount = 0;
    for (const auto& item : cloud) {
        if (item.second.nPointCount > 0) {
            scanPointCount += static_cast<size_t>(item.second.nPointCount);
        }
    }
    if (printDetailLog) {
        LOG_INFO("[ParkingSpaceGuide][Algorithm] planeLocalization begin timestampMs=%lld scanLines=%llu points=%llu simulation=%d\n",
                 static_cast<long long>(frameTimestampMs),
                 static_cast<unsigned long long>(cloud.size()),
                 static_cast<unsigned long long>(scanPointCount),
                 m_simulationOptions.enabled ? 1 : 0);
    }
    const auto localizationStartedAt = std::chrono::steady_clock::now();
    const int ret = m_detectPresenter->DetectParkingSpaceGuide(cloud,
                                                               algorithmParams,
                                                               frameTimestampMs,
                                                               algorithmState,
                                                               result,
                                                               control);
    result.cameraIndex = m_detectIndex;
    if (printDetailLog) {
        const long long elapsedMs =
            std::chrono::duration_cast<std::chrono::milliseconds>(
                std::chrono::steady_clock::now() - localizationStartedAt)
                .count();
        const ParkingSpaceGuideInfo* info =
            result.parkingSpaceInfoList.empty()
            ? nullptr
            : &result.parkingSpaceInfoList.front();
        const int guideStateCode = info ? info->guideStateCode : 0;
        const double distance = info ? info->distance : 0.0;
        const double deviation = info ? info->lateralOffset : 0.0;
        const double angle = info ? info->angle : 0.0;
        const QByteArray algorithmMessage =
            control.planeLocalizationMessage.trimmed().isEmpty()
            ? result.message.toUtf8()
            : control.planeLocalizationMessage.toUtf8();
        LOG_INFO("[ParkingSpaceGuide][Algorithm] planeLocalization end wrapperRet=%d algorithmCode=%d resultCode=%d elapsedMs=%lld state=%d distance=%.3f deviation=%.3f angle=%.3f errorFrames=%d errorFrameThreshold=%d needModelRecognition=%d dockingCompleted=%d message=%s\n",
                 ret,
                 control.planeLocalizationErrorCode,
                 result.errorCode,
                 elapsedMs,
                 guideStateCode,
                 distance,
                 deviation,
                 angle,
                 control.nextState.errorFrameCount,
                 (std::max)(1,
                     algorithmParams.processParam.errorFrameThreshold),
                 control.needModelRecognition ? 1 : 0,
                 control.nextState.dockingCompleted ? 1 : 0,
                 algorithmMessage.constData());
    }

    if (ret != 0) {
        result.errorCode = ret;
        if (result.message.isEmpty()) {
            result.message = QStringLiteral("停机引导检测失败");
        }
    } else {
        if (result.parkingSpaceInfoList.empty() && result.message.isEmpty()) {
            result.message = QStringLiteral("无停机引导结果");
        }

        const VrModelRecognitionParam& modelParam =
            algorithmParams.modelRecognitionParam;
        ModelRecognitionTaskResult completedModelTask;
        if (TakeModelRecognitionTaskResult(completedModelTask)) {
            modelResultApplyGuard.Activate();
            ApplyModelRecognitionTaskResult(completedModelTask,
                                            control.nextState,
                                            result,
                                            modelParam);
        }

        if (control.needModelRecognition) {
            const bool hasSelectedModel =
                !control.nextState.selectedModelType.trimmed().isEmpty();
            const int nextAttempt = hasSelectedModel
                ? (std::max)(0,
                    control.nextState.modelRecognitionAttempts) + 1
                : 1;
            QString schedulingError;
            if (StartModelRecognitionTask(control.recognitionContext,
                                          modelParam,
                                          nextAttempt,
                                          configResult.debugParam,
                                          schedulingError)) {
                control.nextState.modelRecognitionInProgress = true;
                if (hasSelectedModel) {
                    control.nextState.modelRecognitionAttempts = nextAttempt;
                }
            } else if (m_modelRecognitionRunning.load() ||
                       m_modelRecognitionResultReady.load()) {
                control.nextState.modelRecognitionInProgress = true;
                if (printDetailLog) {
                    LOG_INFO("[ParkingSpaceGuide][Algorithm] AAPGS model recognition still running, skip current request\n");
                }
            } else if (!schedulingError.isEmpty()) {
                NotifyStatus(schedulingError.toUtf8().toStdString());
                result.message = result.message.trimmed().isEmpty()
                    ? schedulingError
                    : result.message + QStringLiteral("；") +
                          schedulingError;
            }
        }

        ParkingGuideAlgorithmState& nextState = control.nextState;
        const VrPersonDetectionParam& personParam =
            algorithmParams.personDetectionParam;
        if (!nextState.stopPositionReached && !nextState.dockingCompleted) {
            nextState.lastPersonDetectionTimestampMs = -1;
            nextState.personStableFrameCount = 0;
            nextState.personCount = 0;
            nextState.personConfidence = 0.0;
            nextState.personInChockRegion = false;
            nextState.chocksConfirmed = false;
        } else if (personParam.enabled) {
            const bool modelVerificationSatisfied =
                nextState.modelRecognitionComplete &&
                (nextState.selectedModelType.trimmed().isEmpty() ||
                 nextState.modelVerified);
            const int intervalMs = (std::max)(10,
                                               personParam.detectionIntervalMs);
            const bool detectionDue =
                nextState.lastPersonDetectionTimestampMs < 0 ||
                frameTimestampMs < nextState.lastPersonDetectionTimestampMs ||
                frameTimestampMs - nextState.lastPersonDetectionTimestampMs >=
                    intervalMs;
            if (modelVerificationSatisfied && detectionDue &&
                !nextState.chocksConfirmed) {
                nextState.lastPersonDetectionTimestampMs = frameTimestampMs;
                QImage personSourceImage;
                QImage personRoiImage;
                QRect personSourceRoi;
                QString captureError;
                PersonDetectionResult personResult;
                if (!CaptureModelRecognitionImage(personSourceImage,
                                                  captureError) ||
                    !CropNormalizedRoi(personSourceImage,
                                       personParam.roiX,
                                       personParam.roiY,
                                       personParam.roiWidth,
                                       personParam.roiHeight,
                                       personRoiImage,
                                       captureError,
                                       &personSourceRoi)) {
                    nextState.personStableFrameCount = 0;
                    nextState.personCount = 0;
                    nextState.personConfidence = 0.0;
                    nextState.personInChockRegion = false;
                    const QString message = captureError.trimmed().isEmpty()
                        ? QStringLiteral("人员检测相机图像不可用")
                        : captureError.trimmed();
                    NotifyStatus(message.toUtf8().toStdString());
                } else {
                    if (printDetailLog) {
                        LOG_INFO("[ParkingSpaceGuide][Algorithm] Persion_model person detection begin roiImage=%dx%d roi=(%.6f,%.6f,%.6f,%.6f) threshold=%.6f\n",
                                 personRoiImage.width(),
                                 personRoiImage.height(),
                                 personParam.roiX,
                                 personParam.roiY,
                                 personParam.roiWidth,
                                 personParam.roiHeight,
                                 personParam.confidenceThreshold);
                    }
                    const auto personDetectionStartedAt =
                        std::chrono::steady_clock::now();
                    const int personRet =
                        m_detectPresenter->DetectPersonInRegion2D(
                            personRoiImage, personParam, personResult);
                    if (printDetailLog) {
                        const long long elapsedMs =
                            std::chrono::duration_cast<std::chrono::milliseconds>(
                                std::chrono::steady_clock::now() -
                                personDetectionStartedAt)
                                .count();
                        const QByteArray personMessage =
                            personResult.message.toUtf8();
                        LOG_INFO("[ParkingSpaceGuide][Algorithm] Persion_model person detection end ret=%d elapsedMs=%lld detectedBoxes=%d regionCount=%d confidence=%.6f inRegion=%d message=%s\n",
                                 personRet,
                                 elapsedMs,
                                 static_cast<int>(personResult.personBoxes.size()),
                                 personResult.personCount,
                                 personResult.confidence,
                                 personResult.personInRegion ? 1 : 0,
                                 personMessage.constData());
                    }
                    if (personRet != 0) {
                        nextState.personStableFrameCount = 0;
                        nextState.personCount = 0;
                        nextState.personConfidence = 0.0;
                        nextState.personInChockRegion = false;
                        const QString message =
                            personResult.message.trimmed().isEmpty()
                            ? QStringLiteral("轮挡区域人员检测失败")
                            : personResult.message.trimmed();
                        NotifyStatus(message.toUtf8().toStdString());
                    } else {
                        PersonDetectionResult displayResult = personResult;
                        displayResult.roi = QRectF(personSourceRoi);
                        const QPointF roiOffset = personSourceRoi.topLeft();
                        for (QRectF& box : displayResult.personBoxes) {
                            box.translate(roiOffset);
                        }
                        result.image = DrawPersonDetectionOverlay(
                            personSourceImage,
                            displayResult);
                        result.imageIsRoi = false;
                        nextState.personCount = personResult.personCount;
                        nextState.personConfidence = personResult.confidence;
                        nextState.personInChockRegion = personResult.personInRegion;
                        nextState.personStableFrameCount = personResult.personInRegion
                            ? (std::max)(0, nextState.personStableFrameCount) + 1
                            : 0;
                        nextState.chocksConfirmed =
                            nextState.personStableFrameCount >=
                            (std::max)(1, personParam.stableFrames);
                    }
                }
            }

            for (ParkingSpaceGuideInfo& info : result.parkingSpaceInfoList) {
                const ParkingGuideState currentState =
                    ParkingGuideStateFromCode(info.guideStateCode);
                if (!modelVerificationSatisfied &&
                    currentState ==
                        ParkingGuideState::AircraftVerificationFailed) {
                    continue;
                }
                if (!modelVerificationSatisfied) {
                    info.guideStateCode =
                        static_cast<int>(ParkingGuideState::StopPositionReached);
                    info.guideText = QStringLiteral("STOP");
                    info.hasException = false;
                    nextState.lastGuideStateCode = info.guideStateCode;
                    result.message = QStringLiteral(
                        "飞机已停稳，等待完成飞机目标检测");
                } else if (nextState.chocksConfirmed) {
                    info.guideStateCode =
                        static_cast<int>(ParkingGuideState::ChocksOn);
                    info.guideText = QStringLiteral("CHOCK ON");
                    info.hasException = false;
                    nextState.lastGuideStateCode = info.guideStateCode;
                    result.message = QStringLiteral(
                        "轮挡区域人员检测已确认，轮挡固定流程完成");
                } else if (nextState.dockingCompleted) {
                    info.guideStateCode =
                        static_cast<int>(ParkingGuideState::DockingCompleted);
                    info.guideText = QStringLiteral("OK");
                    info.hasException = false;
                    nextState.lastGuideStateCode = info.guideStateCode;
                    result.message = QStringLiteral(
                        "飞机已停稳，系统已切换为OK，等待上下轮挡");
                } else {
                    info.guideStateCode =
                        static_cast<int>(ParkingGuideState::StopPositionReached);
                    info.guideText = QStringLiteral("STOP");
                    info.hasException = false;
                    nextState.lastGuideStateCode = info.guideStateCode;
                    result.message = QStringLiteral(
                        "飞机已停稳，等待人员进入轮挡区域固定轮胎");
                }
            }
        }
    }

    if (ret == 0) {
        algorithmState = control.nextState;
    }
    UpdateDetectionResultModelFields(result, algorithmState);
    if (algorithmState.chocksConfirmed) {
        bool firstPersonChock = false;
        {
            std::lock_guard<std::mutex> recordLock(m_recordMutex);
            if (m_personChockTimeMs <= 0) {
                m_personChockTimeMs = QDateTime::currentMSecsSinceEpoch();
                firstPersonChock = true;
            }
        }
        if (firstPersonChock) {
            RecordGuideEvent(QStringLiteral("person_chock"),
                             QStringLiteral("轮挡区域人员检测已确认"));
            if (m_guideRecordStore) {
                qint64 personTime = 0;
                qint64 onTime = 0;
                qint64 offTime = 0;
                {
                    std::lock_guard<std::mutex> recordLock(m_recordMutex);
                    personTime = m_personChockTimeMs;
                    onTime = m_chockOnTimeMs;
                    offTime = m_chockOffTimeMs;
                }
                m_guideRecordStore->UpdateChockTimes(
                    CurrentSessionUuid(), personTime, onTime, offTime);
            }
        }
    }
    for (ParkingSpaceGuideInfo& info : result.parkingSpaceInfoList) {
        info.personInChockRegion = algorithmState.personInChockRegion;
        info.chocksConfirmed = algorithmState.chocksConfirmed;
        info.personCount = algorithmState.personCount;
        info.personConfidence = std::isfinite(algorithmState.personConfidence)
            ? algorithmState.personConfidence
            : 0.0;
    }
    PublishDetectionResult(result);
    return ret == 0;
}

std::shared_ptr<ParkingSpaceGuidePresenter::OwnedCloudFrame>
ParkingSpaceGuidePresenter::AcquireCloudFrameBuffer()
{
    std::lock_guard<std::mutex> dataLock(m_dataMutex);
    for (size_t i = 0; i < m_cloudFrameSlots.size(); ++i) {
        const size_t slotIndex = (m_nextCloudFrameSlot + i) % m_cloudFrameSlots.size();
        std::shared_ptr<OwnedCloudFrame>& slot = m_cloudFrameSlots[slotIndex];
        if (!slot) {
            slot = std::make_shared<OwnedCloudFrame>();
        }
        if (slot.use_count() == 1) {
            m_nextCloudFrameSlot = (slotIndex + 1) % m_cloudFrameSlots.size();
            return slot;
        }
    }
    return std::shared_ptr<OwnedCloudFrame>();
}

bool ParkingSpaceGuidePresenter::CopyCloudFrame(const RsCloudData& cloud,
                                                const RsFrameInfo& info,
                                                OwnedCloudFrame& destination)
{
    size_t totalPointCount = 0;
    for (const auto& item : cloud) {
        const SVzLaserLineData& line = item.second;
        if (item.first != keResultDataType_PointXYZI ||
            line.nPointCount < 0 ||
            (line.nPointCount > 0 && !line.p3DPoint)) {
            return false;
        }
        totalPointCount += static_cast<size_t>(line.nPointCount);
    }

    destination.points.resize(totalPointCount);
    destination.cloud.clear();
    destination.cloud.reserve(cloud.size());
    destination.info = info;
    destination.timestampMs = MonotonicMilliseconds();

    size_t pointOffset = 0;
    for (const auto& item : cloud) {
        SVzLaserLineData line = item.second;
        line.p2DPoint = nullptr;
        if (line.nPointCount > 0) {
            SVzNLPointXYZI* target = destination.points.data() + pointOffset;
            std::memcpy(target,
                        line.p3DPoint,
                        sizeof(SVzNLPointXYZI) * static_cast<size_t>(line.nPointCount));
            line.p3DPoint = target;
            pointOffset += static_cast<size_t>(line.nPointCount);
        } else {
            line.p3DPoint = nullptr;
        }
        destination.cloud.emplace_back(item.first, line);
    }
    return true;
}

bool ParkingSpaceGuidePresenter::SubmitCloudFrame(const RsCloudData& cloud,
                                                   const RsFrameInfo& info)
{
    try {
        std::shared_ptr<OwnedCloudFrame> frame = AcquireCloudFrameBuffer();
        if (!frame) {
            return false;
        }
        if (!CopyCloudFrame(cloud, info, *frame)) {
            if (!m_cloudCopyErrorReported.exchange(true)) {
                NotifyStatus("雷达点云格式非 PointXYZI，已丢弃当前帧");
            }
            return false;
        }

        m_cloudCopyErrorReported.store(false);
        return SubmitOwnedCloudFrame(frame) != 0;
    } catch (const std::exception& e) {
        if (!m_cloudCopyErrorReported.exchange(true)) {
            NotifyStatus(std::string("复制雷达点云失败：") + e.what());
        }
    } catch (...) {
        if (!m_cloudCopyErrorReported.exchange(true)) {
            NotifyStatus("复制雷达点云发生未知异常");
        }
    }
    return false;
}

unsigned long long ParkingSpaceGuidePresenter::SubmitOwnedCloudFrame(
    const std::shared_ptr<OwnedCloudFrame>& frame)
{
    if (!frame ||
        (m_simulationOptions.enabled && m_stopDetectionRequested.load())) {
        return 0;
    }

    unsigned long long sequence = 0;
    {
        std::lock_guard<std::mutex> dataLock(m_dataMutex);
        if (m_simulationOptions.enabled && m_stopDetectionRequested.load()) {
            return 0;
        }
        m_latestCloudFrame = frame;
        sequence = ++m_cloudSequence;
    }
    MarkLidarFrameAlive();
    m_detectionCondition.notify_all();
    return sequence;
}

bool ParkingSpaceGuidePresenter::WaitForSimulationFrameProcessed(
    unsigned long long sequence)
{
    std::unique_lock<std::mutex> dataLock(m_dataMutex);
    m_detectionCondition.wait(dataLock, [this, sequence]() {
        return m_stopDetectionRequested.load() ||
               m_processedCloudSequence >= sequence;
    });
    return !m_stopDetectionRequested.load() &&
           m_processedCloudSequence >= sequence;
}

bool ParkingSpaceGuidePresenter::WaitForSimulationInterval(int intervalMs)
{
    if (intervalMs <= 0) {
        return !m_stopDetectionRequested.load();
    }
    std::unique_lock<std::mutex> dataLock(m_dataMutex);
    const bool stopped = m_detectionCondition.wait_for(
        dataLock,
        std::chrono::milliseconds(intervalMs),
        [this]() { return m_stopDetectionRequested.load(); });
    return !stopped;
}

void ParkingSpaceGuidePresenter::SimulationPlaybackLoop()
{
    const bool printDetailLog = m_configManager &&
        m_configManager->GetConfigResult().debugParam.printDetailLog;
    const auto failPlayback = [this](const QString& message) {
        const QString text = message.trimmed().isEmpty()
            ? QStringLiteral("仿真回放失败")
            : message.trimmed();
        NotifyStatus(text.toUtf8().toStdString());
        PublishErrorResult(-1, text);
        m_stopDetectionRequested.store(true);
        m_detectionRunning.store(false);
        m_automaticDetection.store(false);
        m_trackingMode.store(false);
        NotifyWorkStatus(WorkStatus::Error);
        m_detectionCondition.notify_all();
    };

    bool playbackCompleted = false;
    size_t playbackRound = 0;
    while (!m_stopDetectionRequested.load()) {
        ++playbackRound;
        m_simulationRound.store(
            static_cast<unsigned long long>(playbackRound));
        if (playbackRound > 1) {
            NotifyStatus(QStringLiteral("开始第 %1 轮仿真回放")
                             .arg(playbackRound)
                             .toUtf8()
                             .toStdString());
        }

        for (size_t frameIndex = 0;
             frameIndex < m_simulationRadarFrames.size();
             ++frameIndex) {
            if (m_stopDetectionRequested.load()) {
                break;
            }

            const auto frameStartedAt = std::chrono::steady_clock::now();
            const std::shared_ptr<OwnedCloudFrame>& radarFrame =
                m_simulationRadarFrames[frameIndex];
            radarFrame->timestampMs = static_cast<qint64>(frameIndex) *
                static_cast<qint64>(m_simulationOptions.frameIntervalMs);
            const size_t imageIndex =
                frameIndex % m_simulationCameraFrames.size();
            const QImage& cameraFrame = m_simulationCameraFrames[imageIndex];
            CacheSimulationCameraFrame(frameIndex, cameraFrame);
            if (m_stopDetectionRequested.load()) {
                return;
            }

            const unsigned long long sequence =
                SubmitOwnedCloudFrame(radarFrame);
            if (sequence == 0) {
                if (m_stopDetectionRequested.load()) {
                    return;
                }
                failPlayback(QStringLiteral("提交仿真雷达帧失败：%1")
                                 .arg(QFileInfo(
                                     m_simulationRadarFiles[frameIndex])
                                     .fileName()));
                return;
            }

            if (printDetailLog ||
                frameIndex == 0 ||
                frameIndex + 1 == m_simulationRadarFrames.size() ||
                (frameIndex + 1) % 10 == 0) {
                NotifyStatus(QStringLiteral("仿真帧 %1/%2：%3 + %4")
                                 .arg(frameIndex + 1)
                                 .arg(m_simulationRadarFrames.size())
                                 .arg(QFileInfo(
                                     m_simulationRadarFiles[frameIndex])
                                     .fileName())
                                 .arg(QFileInfo(
                                     m_simulationCameraFiles[imageIndex])
                                     .fileName())
                                 .toUtf8()
                                 .toStdString());
            }
            if (!WaitForSimulationFrameProcessed(sequence)) {
                return;
            }

            const bool hasNextFrame =
                frameIndex + 1 < m_simulationRadarFrames.size();
            const bool repeatPlayback =
                m_simulationOptions.loop || m_automaticDetection.load();
            if (hasNextFrame || repeatPlayback) {
                const long long elapsedMs =
                    std::chrono::duration_cast<std::chrono::milliseconds>(
                        std::chrono::steady_clock::now() - frameStartedAt)
                        .count();
                const int remainingMs = elapsedMs >=
                        static_cast<long long>(m_simulationOptions.frameIntervalMs)
                    ? 0
                    : m_simulationOptions.frameIntervalMs -
                          static_cast<int>(elapsedMs);
                if (!WaitForSimulationInterval(remainingMs)) {
                    return;
                }
            }
        }

        if (m_stopDetectionRequested.load()) {
            break;
        }
        {
            std::unique_lock<std::mutex> dataLock(m_dataMutex);
            m_detectionCondition.wait(dataLock, [this]() {
                return m_stopDetectionRequested.load() ||
                       (!m_modelRecognitionRunning.load() &&
                        !m_modelRecognitionResultReady.load() &&
                        !m_modelRecognitionResultApplying.load());
            });
        }
        if (m_stopDetectionRequested.load()) {
            break;
        }
        if (!m_simulationOptions.loop &&
            !m_automaticDetection.load()) {
            playbackCompleted = true;
            break;
        }
    }

    if (playbackCompleted) {
        m_stopDetectionRequested.store(true);
        m_detectionRunning.store(false);
        m_automaticDetection.store(false);
        m_trackingMode.store(false);
        m_detectionCondition.notify_all();
        const QString message = QStringLiteral(
            "仿真回放完成，共处理 %1 帧，最终引导状态未完成")
                                    .arg(m_simulationRadarFrames.size());
        NotifyWorkStatus(WorkStatus::Completed);
        NotifyStatus(message.toUtf8().toStdString());
    }
}

bool ParkingSpaceGuidePresenter::ProcessAirplanePresence(const RsCloudData& cloud)
{
    AirplanePresenceResult presence;
    const int ret = m_detectPresenter->DetectAirplanePresence(
        cloud,
        m_configManager->GetAlgorithmParams(),
        presence);
    if (ret != 0) {
        const QString message = presence.message.trimmed().isEmpty()
            ? QStringLiteral("飞机存在检测失败")
            : presence.message.trimmed();
        PublishErrorResult(ret, message);
        return false;
    }

    if (presence.state == AirplanePresenceState::Detected) {
        NotifyStatus("检测到飞机，进入引导检测");
        return true;
    }

    ParkingGuideState guideState = ParkingGuideState::Unknown;
    QString guideText;
    if (presence.state == AirplanePresenceState::GateBlocked) {
        guideState = ParkingGuideState::GateBlocked;
        guideText = QStringLiteral("GATEBLOCK");
    } else if (presence.state == AirplanePresenceState::ViewBlocked) {
        guideState = ParkingGuideState::ViewBlocked;
        guideText = QStringLiteral("VIEWBLOCKED");
    } else {
        return false;
    }

    DetectionResult result;
    ParkingSpaceGuideInfo info;
    info.hasException = true;
    info.guideStateCode = static_cast<int>(guideState);
    info.guideText = guideText;
    result.parkingSpaceInfoList.push_back(info);
    result.message = presence.message.trimmed().isEmpty() ? guideText : presence.message.trimmed();
    PublishDetectionResult(result);
    return false;
}

void ParkingSpaceGuidePresenter::PublishDetectionResult(DetectionResult& result,
                                                         bool safetyResult)
{
    {
        std::lock_guard<std::mutex> publishLock(m_publishMutex);
        if (!safetyResult && ShouldHoldSafetyState()) {
            return;
        }

        if (m_simulationOptions.enabled && result.image.isNull()) {
            std::lock_guard<std::mutex> dataLock(m_dataMutex);
            result.image = m_simulationCameraImage;
        }
        EnrichDetectionResult(result);
        ApplySessionDisplayFields(result);
        if (!safetyResult && result.errorCode == 0 &&
            !result.parkingSpaceInfoList.empty()) {
            m_lastDetectionResult = result;
        }
        if (StatusCallback()) {
            StatusCallback()->OnDetectionResult(result);
        }
        UpdateCurrentStatus(result);
        RecordGuideSample(result);
    }

    if (m_remoteServer) {
        m_remoteServer->PublishStatus(CurrentStatusJson());
    }

    // Do not let a slow LED acknowledgement delay UI and HTTP safety state.
    // The second interlock check prevents queued normal results from being
    // emitted after an emergency-stop result has already been committed.
    std::lock_guard<std::mutex> outputLock(m_outputMutex);
    if (!safetyResult && ShouldHoldSafetyState()) {
        return;
    }
    if (m_ledDisplay) {
        m_ledDisplay->SendResult(ConvertLedResult(result));
    }
    if (!safetyResult && ShouldHoldSafetyState()) {
        return;
    }
    BroadcastDetectionResult(result);
}

void ParkingSpaceGuidePresenter::PublishErrorResult(int errorCode, const QString& message)
{
    DetectionResult result;
    result.errorCode = errorCode == 0 ? -1 : errorCode;
    result.message = message;
    PublishDetectionResult(result);
}

DetectionResult ParkingSpaceGuidePresenter::CreateGuideStateResult(
    ParkingGuideState state,
    const QString& guideText,
    const QString& message,
    bool preserveLastMeasurement) const
{
    DetectionResult result;
    if (preserveLastMeasurement) {
        std::lock_guard<std::mutex> publishLock(m_publishMutex);
        if (!m_lastDetectionResult.parkingSpaceInfoList.empty()) {
            result = m_lastDetectionResult;
        }
    }

    const UdpBroadcastConfig config = m_configManager
        ? m_configManager->GetConfigResult().udpBroadcastConfig
        : m_udpBroadcastConfig;
    ParkingSpaceGuideInfo info = result.parkingSpaceInfoList.empty()
        ? FallbackGuideInfo(config)
        : result.parkingSpaceInfoList.front();
    {
        std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
        if (!m_selectedModelType.isEmpty()) {
            info.expectedModelType = m_selectedModelType;
        }
    }
    info.guideStateCode = static_cast<int>(state);
    info.guideText = guideText;
    info.hasException = IsExceptionGuideState(static_cast<int>(state));

    result.errorCode = 0;
    result.message = message;
    result.parkingSpaceInfoList.clear();
    result.parkingSpaceInfoList.push_back(info);
    return result;
}

void ParkingSpaceGuidePresenter::PublishGuideState(
    ParkingGuideState state,
    const QString& guideText,
    const QString& message,
    bool preserveLastMeasurement)
{
    DetectionResult result = CreateGuideStateResult(
        state, guideText, message, preserveLastMeasurement);
    PublishDetectionResult(result, true);
}

bool ParkingSpaceGuidePresenter::PublishCurrentSafetyState(
    bool publishWaitingWhenClear,
    bool preserveLastMeasurement)
{
    std::lock_guard<std::mutex> safetyPublishLock(m_safetyPublishMutex);
    if (m_reconfiguring.load()) {
        return false;
    }

    ParkingGuideState guideState = ParkingGuideState::Waiting;
    WorkStatus workStatus = WorkStatus::Ready;
    QString guideText = QStringLiteral("WAIT");
    QString message = QStringLiteral("等待飞机进入引导区域");
    bool shouldPublish = publishWaitingWhenClear;

    if (m_emergencyStopEnabled.load() &&
        m_emergencyStopActive.load()) {
        guideState = ParkingGuideState::EmergencyStop;
        workStatus = WorkStatus::EmergencyStop;
        guideText = QStringLiteral("STOP");
        message = QStringLiteral("急停按钮已按下，停机引导已停止");
        shouldPublish = true;
    } else if (m_emergencyStopEnabled.load() &&
               !m_emergencyStopAvailable.load()) {
        guideState = ParkingGuideState::SystemFailure;
        workStatus = WorkStatus::Error;
        guideText = QStringLiteral("FAIL");
        message = QStringLiteral("急停输入不可用");
        shouldPublish = true;
    } else if (HasRequiredDeviceOffline()) {
        guideState = ParkingGuideState::SystemError;
        workStatus = WorkStatus::Error;
        guideText = QStringLiteral("ERROR");
        message = DeviceOfflineMessage();
        shouldPublish = true;
    } else if (HasSelfCheckFailed()) {
        const SelfCheckResult lastCheck = LastSelfCheckResult();
        guideState = ParkingGuideState::SystemError;
        workStatus = WorkStatus::Error;
        guideText = QStringLiteral("ERROR");
        message = lastCheck.message;
        shouldPublish = true;
    } else if (m_emergencyStopLatched.load()) {
        message = QStringLiteral("急停已解除，请重新点击开始");
        shouldPublish = true;
    }

    if (!shouldPublish) {
        return false;
    }

    DetectionResult result = CreateGuideStateResult(
        guideState,
        guideText,
        message,
        preserveLastMeasurement &&
            guideState != ParkingGuideState::Waiting);
    if (guideState == ParkingGuideState::SystemFailure) {
        result.errorCode = kDeviceErrorEmergency;
    } else if (guideState == ParkingGuideState::SystemError) {
        result.errorCode = HasRequiredDeviceOffline()
            ? DeviceOfflineErrorCode()
            : LastSelfCheckResult().errorCode;
    }
    PublishDetectionResult(result, true);
    NotifyWorkStatus(workStatus);
    return true;
}

void ParkingSpaceGuidePresenter::RequestDetectionStopForSafety()
{
    {
        std::lock_guard<std::mutex> dataLock(m_dataMutex);
        m_stopDetectionRequested.store(true);
    }
    m_detectionRunning.store(false);
    m_automaticDetection.store(false);
    m_trackingMode.store(false);
    m_detectionCondition.notify_all();
}

void ParkingSpaceGuidePresenter::HandleEmergencyStopChanged(bool active)
{
    if (m_emergencyStopIgnored.load()) {
        return;
    }

    bool changed = false;
    {
        std::lock_guard<std::mutex> safetyLock(m_safetyMutex);
        if (!m_emergencyStopEnabled.load()) {
            return;
        }

        changed = m_emergencyStopActive.load() != active;
        m_emergencyStopActive.store(active);
        if (active) {
            m_emergencyStopLatched.store(true);
            RequestDetectionStopForSafety();
        }
    }

    if (!changed || !m_initialized.load() || m_reconfiguring.load()) {
        return;
    }

    PublishCurrentSafetyState(false, true);
    if (active) {
        NotifyStatus("检测到急停输入，停机引导已进入紧急停止状态");
    } else {
        NotifyStatus("急停输入已解除，等待重新点击开始");
    }
}

void ParkingSpaceGuidePresenter::HandleEmergencyStopStatus(
    bool available,
    const std::string& message)
{
    if (m_emergencyStopIgnored.load()) {
        return;
    }

    bool freshActive = false;
    if (available && m_emergencyStopInput) {
        freshActive = m_emergencyStopInput->IsActive();
    }

    bool safetyStateChanged = false;
    {
        std::lock_guard<std::mutex> safetyLock(m_safetyMutex);
        if (!m_emergencyStopEnabled.load()) {
            return;
        }

        const bool previousAvailable = m_emergencyStopAvailable.load();
        const bool previousActive = m_emergencyStopActive.load();
        m_emergencyStopAvailable.store(available);
        if (available) {
            m_emergencyStopActive.store(freshActive);
            if (freshActive) {
                m_emergencyStopLatched.store(true);
                RequestDetectionStopForSafety();
            }
        } else {
            m_emergencyStopLatched.store(true);
            RequestDetectionStopForSafety();
        }
        safetyStateChanged = previousAvailable != available ||
            (available && previousActive != freshActive);
    }

    const std::string prefix = available
        ? "急停输入："
        : "急停输入异常：";
    NotifyStatus(prefix + message);

    if (safetyStateChanged && m_initialized.load() &&
        !m_reconfiguring.load()) {
        // A successful first read may arrive after Init() published its
        // fail-closed placeholder. Publish the clear state as well so UI and
        // protocols cannot remain stuck on SystemFailure.
        PublishCurrentSafetyState(available, true);
    }
}

void ParkingSpaceGuidePresenter::StartOfficialVideoStreamIfNeeded()
{
    if (m_simulationOptions.enabled ||
        m_shutdownRequested.load() ||
        !m_configManager) {
        return;
    }

    const ConfigResult streamConfig = m_configManager->GetConfigResult();
    if (m_videoStreamThread.joinable() &&
        m_videoStreamRunning.load() &&
        !m_videoStreamStopRequested.load()) {
        return;
    }
    StartVideoStream(streamConfig.httpFlvStreamConfig,
                     streamConfig.mvsCamera);
}

void ParkingSpaceGuidePresenter::StartVideoStream(
    const HttpFlvStreamConfig& config,
    const MvsCameraConfig& cameraConfig)
{
    NotifyStatus(
        QStringLiteral(
            "HTTP-FLV实时视频启动检查：enabled=%1，simulation=%2，detectionRunning=%3，"
            "RTMP=%4:%5%6，HTTP端口=%7")
            .arg(config.enabled ? 1 : 0)
            .arg(m_simulationOptions.enabled ? 1 : 0)
            .arg(m_detectionRunning.load() ? 1 : 0)
            .arg(QString::fromStdString(config.publishHost))
            .arg(config.publishPort)
            .arg(QString::fromStdString(config.publishPath))
            .arg(config.httpPort)
            .toUtf8()
            .toStdString());

    StopVideoStream();
    if (m_shutdownRequested.load()) {
        return;
    }
    if (!config.enabled) {
        NotifyStatus("HTTP-FLV实时视频未启动：配置已禁用");
        return;
    }
    // 仿真仍跟检测会话走；正式工作在初始化后常开，不要求检测正在运行。
    if (m_simulationOptions.enabled && !m_detectionRunning.load()) {
        NotifyStatus("HTTP-FLV实时视频未启动：仿真回放未运行");
        return;
    }

    m_videoStreamStopRequested.store(false);
    try {
        m_videoStreamThread = std::thread(
            &ParkingSpaceGuidePresenter::VideoStreamLoop,
            this,
            config,
            cameraConfig);
        NotifyStatus("HTTP-FLV实时视频线程已创建");
    } catch (const std::exception& e) {
        m_videoStreamStopRequested.store(true);
        NotifyStatus(
            QStringLiteral("启动HTTP-FLV实时视频线程失败：%1，停机引导继续运行")
                .arg(QString::fromUtf8(e.what()))
                .toUtf8()
                .toStdString());
    } catch (...) {
        m_videoStreamStopRequested.store(true);
        NotifyStatus("启动HTTP-FLV实时视频线程失败：未知异常，停机引导继续运行");
    }
}

void ParkingSpaceGuidePresenter::RequestVideoStreamStop()
{
    m_videoStreamStopRequested.store(true);
    m_videoStreamCondition.notify_all();
}

void ParkingSpaceGuidePresenter::StopVideoStream()
{
    RequestVideoStreamStop();
    if (m_videoStreamThread.joinable() &&
        m_videoStreamThread.get_id() != std::this_thread::get_id()) {
        m_videoStreamThread.join();
    }
    m_videoStreamRunning.store(false);
}

void ParkingSpaceGuidePresenter::VideoStreamLoop(
    HttpFlvStreamConfig config,
    MvsCameraConfig cameraConfig)
{
    m_videoStreamRunning.store(true);
    std::unique_ptr<IVrFFMediaPusher> pusher;
    unsigned int activeWidth = 0;
    unsigned int activeHeight = 0;
    EFFPushPixelFormat activePixelFormat = EFFPushPixelFormat::GRAY8;
    std::string lastFailure;
    std::string lastExposureFailure;
    bool firstFrameReported = false;
    bool autoExposureInitialized = false;
    unsigned long long lastAcceptedFrameId = 0;
    unsigned long long lastAcceptedTimestamp = 0;
    vision::FixedRoiAutoExposureSession autoExposureSession;
    const auto streamStartedAt = std::chrono::steady_clock::now();
    auto nextFrameAt = streamStartedAt;
    auto lastExposureAt = streamStartedAt -
        std::chrono::milliseconds(kAutoExposureMinIntervalMs);
    const int streamFps = OfficialVideoFps(config.fps);
    if (streamFps != config.fps) {
        NotifyStatus(
            QStringLiteral("实时视频帧率已限制为 %1 fps，避免占用网卡影响雷达")
                .arg(streamFps)
                .toUtf8()
                .toStdString());
        config.fps = streamFps;
    }
    const int grabIntervalMs =
        (std::max)(kOfficialVideoMinIntervalMs, 1000 / config.fps);

    NotifyStatus(
        QStringLiteral("HTTP-FLV实时视频线程开始运行：RTMP=%1:%2%3")
            .arg(QString::fromStdString(config.publishHost))
            .arg(config.publishPort)
            .arg(QString::fromStdString(config.publishPath))
            .toUtf8()
            .toStdString());

    const auto reportFailure = [this, &lastFailure](const std::string& message) {
        if (lastFailure != message) {
            NotifyStatus(message);
            lastFailure = message;
        }
    };
    const auto reportExposureFailure =
        [this, &lastExposureFailure](const std::string& message) {
            if (lastExposureFailure != message) {
                NotifyStatus(message);
                lastExposureFailure = message;
            }
        };

    const auto closePusher = [&]() {
        if (pusher) {
            pusher->Stop();
            pusher->UnInit();
            pusher.reset();
        }
        activeWidth = 0;
        activeHeight = 0;
    };
    const auto waitForStop = [this](int milliseconds) {
        std::unique_lock<std::mutex> lock(m_videoStreamMutex);
        return m_videoStreamCondition.wait_for(
            lock,
            std::chrono::milliseconds(milliseconds),
            [this]() { return m_videoStreamStopRequested.load(); });
    };
    const auto adjustAutoExposure =
        [this,
         &cameraConfig,
         &autoExposureInitialized,
         &autoExposureSession,
         &lastExposureFailure,
         &reportExposureFailure](const MvsImageData& image) {
            if (m_simulationOptions.enabled ||
                !cameraConfig.autoExposureEnabled) {
                return;
            }

            const unsigned int channels =
                image.pixelFormat == kMvsPixelTypeMono8 ? 1U : 3U;
            const unsigned long long requiredBytes =
                static_cast<unsigned long long>(image.width) *
                static_cast<unsigned long long>(image.height) * channels;
            if (!image.pData || image.dataSize < requiredBytes) {
                reportExposureFailure(
                    "固定ROI自动曝光跳过：图像缓冲大小不足");
                return;
            }

            cv::Mat exposureImage;
            cv::Mat convertedImage;
            if (image.pixelFormat == kMvsPixelTypeMono8) {
                exposureImage = cv::Mat(
                    static_cast<int>(image.height),
                    static_cast<int>(image.width),
                    CV_8UC1,
                    image.pData);
            } else if (image.pixelFormat == kMvsPixelTypeBGR8) {
                exposureImage = cv::Mat(
                    static_cast<int>(image.height),
                    static_cast<int>(image.width),
                    CV_8UC3,
                    image.pData);
            } else if (image.pixelFormat == kMvsPixelTypeRGB8) {
                const cv::Mat rgbImage(
                    static_cast<int>(image.height),
                    static_cast<int>(image.width),
                    CV_8UC3,
                    image.pData);
                cv::cvtColor(rgbImage, convertedImage, cv::COLOR_RGB2BGR);
                exposureImage = convertedImage;
            } else {
                return;
            }

            std::lock_guard<std::mutex> cameraLock(m_cameraCaptureMutex);
            if (!m_mvsDevice || !m_mvsDevice->IsDeviceOpen()) {
                reportExposureFailure(
                    "固定ROI自动曝光跳过：相机已断开");
                return;
            }

            if (!autoExposureInitialized ||
                !autoExposureSession.calibration().isValidFor(
                    exposureImage.size())) {
                MvsFloatFeatureInfo exposureInfo;
                MvsFloatFeatureInfo gainInfo;
                const int exposureInfoRet = m_mvsDevice->GetFloatFeatureInfo(
                    "ExposureTime", exposureInfo);
                const int gainInfoRet = m_mvsDevice->GetFloatFeatureInfo(
                    "Gain", gainInfo);
                if (exposureInfoRet != 0 || gainInfoRet != 0) {
                    reportExposureFailure(
                        QStringLiteral(
                            "初始化固定ROI自动曝光失败：exposureInfoRet=%1，"
                            "gainInfoRet=%2")
                            .arg(exposureInfoRet)
                            .arg(gainInfoRet)
                            .toUtf8()
                            .toStdString());
                    return;
                }

                const int imageWidth = static_cast<int>(image.width);
                const int imageHeight = static_cast<int>(image.height);
                const cv::Rect roi = NormalizedExposureRoi(
                    cameraConfig, imageWidth, imageHeight);
                const double effectiveFrameRate = cameraConfig.frameRate > 0.0
                    ? cameraConfig.frameRate
                    : 10.0;
                const double framePeriodExposureLimit =
                    900000.0 / effectiveFrameRate;
                const double exposureMaximum = (std::max)(
                    exposureInfo.minimum,
                    (std::min)(exposureInfo.maximum,
                               framePeriodExposureLimit));

                if (!autoExposureSession.setGrayTolerance(
                        cameraConfig.exposureGrayTolerance) ||
                    !autoExposureSession.setHardwareLimits(
                        exposureInfo.minimum,
                        exposureMaximum,
                        gainInfo.minimum,
                        gainInfo.maximum) ||
                    !autoExposureSession.restoreCalibration(
                        roi,
                        exposureImage.size(),
                        cameraConfig.exposureReferenceGray)) {
                    reportExposureFailure(
                        "初始化固定ROI自动曝光失败：配置或相机参数范围无效");
                    return;
                }

                autoExposureInitialized = true;
                lastExposureFailure.clear();
                NotifyStatus(
                    QStringLiteral(
                        "固定ROI自动曝光已启用：ROI=(%1,%2,%3,%4)，"
                        "目标灰度=%5±%6，曝光范围=%7~%8，增益范围=%9~%10")
                        .arg(roi.x)
                        .arg(roi.y)
                        .arg(roi.width)
                        .arg(roi.height)
                        .arg(cameraConfig.exposureReferenceGray, 0, 'f', 1)
                        .arg(cameraConfig.exposureGrayTolerance, 0, 'f', 1)
                        .arg(exposureInfo.minimum, 0, 'f', 1)
                        .arg(exposureMaximum, 0, 'f', 1)
                        .arg(gainInfo.minimum, 0, 'f', 2)
                        .arg(gainInfo.maximum, 0, 'f', 2)
                        .toUtf8()
                        .toStdString());
            }

            double currentExposure = 0.0;
            double currentGain = 0.0;
            const int exposureRet =
                m_mvsDevice->GetExposureTime(currentExposure);
            const int gainRet = m_mvsDevice->GetGain(currentGain);
            if (exposureRet != 0 || gainRet != 0) {
                reportExposureFailure(
                    QStringLiteral(
                        "读取固定ROI自动曝光参数失败：exposureRet=%1，gainRet=%2")
                        .arg(exposureRet)
                        .arg(gainRet)
                        .toUtf8()
                        .toStdString());
                autoExposureSession.reset();
                return;
            }

            const vision::FixedRoiExposureSessionResult result =
                autoExposureSession.process(
                    exposureImage, currentExposure, currentGain);
            if (!result.valid) {
                reportExposureFailure(
                    "固定ROI自动曝光计算失败：" + result.error);
                return;
            }
            if (!result.decision.shouldApply) {
                lastExposureFailure.clear();
                return;
            }

            int setExposureRet = 0;
            int setGainRet = 0;
            if (std::abs(result.decision.newExposure - currentExposure) > 1.0) {
                setExposureRet = m_mvsDevice->SetExposureTime(
                    result.decision.newExposure);
            }
            if (std::abs(result.decision.newGain - currentGain) > 0.01) {
                setGainRet = m_mvsDevice->SetGain(result.decision.newGain);
            }
            if (setExposureRet != 0 || setGainRet != 0) {
                reportExposureFailure(
                    QStringLiteral(
                        "写入固定ROI自动曝光参数失败：exposureRet=%1，gainRet=%2")
                        .arg(setExposureRet)
                        .arg(setGainRet)
                        .toUtf8()
                        .toStdString());
                autoExposureSession.reset();
                return;
            }

            lastExposureFailure.clear();
            NotifyStatus(
                QStringLiteral(
                    "固定ROI自动曝光调整：action=%1，mean=%2，"
                    "exposure=%3->%4，gain=%5->%6")
                    .arg(QString::fromLatin1(
                        vision::toString(result.decision.action)))
                    .arg(result.decision.metrics.meanGray, 0, 'f', 1)
                    .arg(currentExposure, 0, 'f', 1)
                    .arg(result.decision.newExposure, 0, 'f', 1)
                    .arg(currentGain, 0, 'f', 2)
                    .arg(result.decision.newGain, 0, 'f', 2)
                    .toUtf8()
                    .toStdString());
        };

    try {
        while (!m_videoStreamStopRequested.load()) {
            MvsImageData captured;
            int captureRet = 0;
            if (m_simulationOptions.enabled) {
                QImage simulationImage;
                {
                    std::lock_guard<std::mutex> dataLock(m_dataMutex);
                    simulationImage = m_simulationCameraImage;
                }
                if (simulationImage.isNull()) {
                    captureRet = -2;
                } else {
                    if (simulationImage.format() != QImage::Format_RGB888) {
                        simulationImage = simulationImage.convertToFormat(
                            QImage::Format_RGB888);
                    }
                    if (simulationImage.isNull()) {
                        captureRet = -3;
                    } else {
                        captured.width = static_cast<unsigned int>(
                            simulationImage.width());
                        captured.height = static_cast<unsigned int>(
                            simulationImage.height());
                        captured.dataSize = captured.width * captured.height * 3U;
                        captured.pixelFormat = kMvsPixelTypeRGB8;
                        captured.pData = new unsigned char[captured.dataSize];
                        const unsigned int rowBytes = captured.width * 3U;
                        for (unsigned int row = 0; row < captured.height; ++row) {
                            std::memcpy(
                                captured.pData + row * rowBytes,
                                simulationImage.constScanLine(
                                    static_cast<int>(row)),
                                rowBytes);
                        }
                    }
                }
            } else {
                std::lock_guard<std::mutex> cameraLock(m_cameraCaptureMutex);
                if (m_videoStreamStopRequested.load()) {
                    break;
                }
                if (!m_mvsDevice || !m_mvsDevice->IsDeviceOpen() ||
                    !m_mvsDevice->IsAcquisitioning()) {
                    captureRet = -1;
                } else {
                    // 连续采集时直接取帧；仅回退软触发时才发 Trigger。
                    if (m_cameraNeedsSoftTrigger.load()) {
                        captureRet = m_mvsDevice->SendSoftTrigger();
                    }
                    if (captureRet == 0) {
                        captureRet = m_mvsDevice->CaptureImage(
                            captured, kVideoCaptureTimeoutMs);
                    }
                }
            }
            std::unique_ptr<unsigned char[]> capturedData(captured.pData);

            if (m_videoStreamStopRequested.load()) {
                break;
            }
            if (captureRet != 0 || !captured.pData || captured.width == 0 ||
                captured.height == 0 || captured.dataSize == 0) {
                reportFailure(
                    QStringLiteral(
                        "实时视频获取%1图像失败：ret=%2，data=%3，width=%4，"
                        "height=%5，size=%6，将自动重试")
                        .arg(m_simulationOptions.enabled
                                 ? QStringLiteral("仿真")
                                 : QStringLiteral("相机"))
                        .arg(captureRet)
                        .arg(captured.pData ? 1 : 0)
                        .arg(captured.width)
                        .arg(captured.height)
                        .arg(captured.dataSize)
                        .toUtf8()
                        .toStdString());
                closePusher();
                if (waitForStop(kVideoReconnectIntervalMs)) {
                    break;
                }
                continue;
            }
            // 只有新帧才刷新在线心跳。SDK 掉线后可能重复吐同一帧，不能算在线。
            bool newFrame = true;
            if (lastAcceptedFrameId != 0 && captured.frameID != 0) {
                newFrame = captured.frameID != lastAcceptedFrameId;
            } else if (lastAcceptedTimestamp != 0 && captured.timestamp != 0) {
                newFrame = captured.timestamp != lastAcceptedTimestamp;
            }
            if (newFrame) {
                if (captured.frameID != 0) {
                    lastAcceptedFrameId = captured.frameID;
                }
                if (captured.timestamp != 0) {
                    lastAcceptedTimestamp = captured.timestamp;
                }
                MarkCameraFrameAlive();
            }

            EFFPushPixelFormat pixelFormat;
            switch (captured.pixelFormat) {
            case kMvsPixelTypeMono8:
                pixelFormat = EFFPushPixelFormat::GRAY8;
                break;
            case kMvsPixelTypeRGB8:
                pixelFormat = EFFPushPixelFormat::RGB24;
                break;
            case kMvsPixelTypeBGR8:
                pixelFormat = EFFPushPixelFormat::BGR24;
                break;
            default:
                reportFailure(
                    QStringLiteral("实时视频不支持相机像素格式%1，将自动重试")
                        .arg(static_cast<unsigned int>(captured.pixelFormat))
                        .toUtf8()
                        .toStdString());
                closePusher();
                if (waitForStop(kVideoReconnectIntervalMs)) {
                    break;
                }
                continue;
            }

            const auto nowBeforeExposure = std::chrono::steady_clock::now();
            if (nowBeforeExposure - lastExposureAt >=
                std::chrono::milliseconds(kAutoExposureMinIntervalMs)) {
                adjustAutoExposure(captured);
                lastExposureAt = nowBeforeExposure;
            }

            IYParkingSpaceGuideStatus* statusCallback = StatusCallback();
            if (statusCallback) {
                QImage previewImage;
                if (CacheMvsFrame(captured, previewImage) &&
                    !previewImage.isNull()) {
                    statusCallback->OnPreviewFrame(previewImage);
                }
            }

            if (!firstFrameReported) {
                NotifyStatus(
                    QStringLiteral("实时视频已获取首帧：%1x%2，size=%3")
                        .arg(captured.width)
                        .arg(captured.height)
                        .arg(captured.dataSize)
                        .toUtf8()
                        .toStdString());
                firstFrameReported = true;
                lastFailure.clear();
            }

            if (pusher &&
                (activeWidth != captured.width ||
                 activeHeight != captured.height ||
                 activePixelFormat != pixelFormat)) {
                closePusher();
            }

            if (!pusher) {
                IVrFFMediaPusher* rawPusher = nullptr;
                if (!IVrFFMediaPusher::CreateObject(&rawPusher) ||
                    !rawPusher) {
                    reportFailure("创建实时视频推流器失败，将自动重试");
                    if (waitForStop(kVideoReconnectIntervalMs)) {
                        break;
                    }
                    continue;
                }
                pusher.reset(rawPusher);

                VrFFPushConfig pushConfig;
                pushConfig.width = captured.width;
                pushConfig.height = captured.height;
                pushConfig.pixelFormat = pixelFormat;
                pushConfig.encodeType = EFFEncodeType::H264;
                pushConfig.fps = static_cast<unsigned int>(config.fps);
                pushConfig.gop = static_cast<unsigned int>(config.gop);
                pushConfig.bitrateKbps =
                    static_cast<unsigned int>(config.bitrateKbps);
                pushConfig.rcMode = EFFRcMode::CBR;
                pushConfig.publishHost = config.publishHost;
                pushConfig.publishPort =
                    static_cast<unsigned short>(config.publishPort);
                pushConfig.publishPath = config.publishPath;

                NotifyStatus(
                    QStringLiteral("实时视频正在连接RTMP：%1:%2%3")
                        .arg(QString::fromStdString(config.publishHost))
                        .arg(config.publishPort)
                        .arg(QString::fromStdString(config.publishPath))
                        .toUtf8()
                        .toStdString());
                const int initRet = pusher->Init(pushConfig);
                const int startRet = initRet == 0 ? pusher->Start() : initRet;
                if (initRet != 0 || startRet != 0) {
                    closePusher();
                    reportFailure(
                        QStringLiteral(
                            "连接ZLMediaKit失败：initRet=%1，startRet=%2，"
                            "实时视频将在后台自动重试，停机引导不受影响")
                            .arg(initRet)
                            .arg(startRet)
                            .toUtf8()
                            .toStdString());
                    if (waitForStop(kVideoReconnectIntervalMs)) {
                        break;
                    }
                    continue;
                }

                activeWidth = captured.width;
                activeHeight = captured.height;
                activePixelFormat = pixelFormat;
                lastFailure.clear();
                NotifyStatus(
                    QStringLiteral("HTTP-FLV实时视频已发布：HTTP端口%1，路径%2.live.flv")
                        .arg(config.httpPort)
                        .arg(QString::fromStdString(config.publishPath))
                        .toUtf8()
                        .toStdString());
            }

            const int64_t ptsUs =
                std::chrono::duration_cast<std::chrono::microseconds>(
                    std::chrono::steady_clock::now() - streamStartedAt)
                    .count();
            if (pusher->PushFrame(
                    captured.pData, captured.dataSize, ptsUs) != 0) {
                closePusher();
                reportFailure("实时视频发布中断，将自动重新连接ZLMediaKit");
                if (waitForStop(kVideoReconnectIntervalMs)) {
                    break;
                }
                continue;
            }

            nextFrameAt += std::chrono::milliseconds(grabIntervalMs);
            const auto now = std::chrono::steady_clock::now();
            if (nextFrameAt < now) {
                // 处理超时就丢节拍，不要连抓把网卡/CPU打满拖死雷达。
                nextFrameAt = now + std::chrono::milliseconds(grabIntervalMs);
            }
            std::unique_lock<std::mutex> lock(m_videoStreamMutex);
            m_videoStreamCondition.wait_until(
                lock,
                nextFrameAt,
                [this]() { return m_videoStreamStopRequested.load(); });
        }
    } catch (const std::exception& e) {
        NotifyStatus(
            QStringLiteral("实时视频线程异常：%1")
                .arg(QString::fromUtf8(e.what()))
                .toUtf8()
                .toStdString());
    } catch (...) {
        NotifyStatus("实时视频线程发生未知异常");
    }

    closePusher();
    m_videoStreamRunning.store(false);
    NotifyStatus("HTTP-FLV实时视频线程已停止");
}

bool ParkingSpaceGuidePresenter::CaptureModelRecognitionImage(QImage& image,
                                                               QString& errorMessage)
{
    image = QImage();
    errorMessage.clear();
    if (m_shutdownRequested.load()) {
        errorMessage = QStringLiteral("应用正在退出");
        return false;
    }
    if (m_simulationOptions.enabled) {
        std::lock_guard<std::mutex> lock(m_dataMutex);
        image = m_simulationCameraImage;
        if (image.isNull()) {
            errorMessage = QStringLiteral("仿真平面相机 BMP 图像不可用");
            return false;
        }
        return true;
    }

    // 机型/人员检测和预览都用推流缓存帧，不再软触发抢相机。
    {
        std::lock_guard<std::mutex> lock(m_dataMutex);
        image = m_latestPreviewImage;
    }
    if (image.isNull()) {
        errorMessage = QStringLiteral("实时视频图像尚未就绪");
        return false;
    }
    return true;
}

bool ParkingSpaceGuidePresenter::StartModelRecognitionTask(
    const QByteArray& recognitionContext,
    const VrModelRecognitionParam& modelParam,
    int attempt,
    const VrDebugParam& debugParam,
    QString& errorMessage)
{
    errorMessage.clear();
    if (m_shutdownRequested.load()) {
        errorMessage = QStringLiteral("应用正在退出");
        return false;
    }
    std::lock_guard<std::mutex> lock(m_modelRecognitionMutex);
    if (m_modelRecognitionRunning.load() ||
        m_modelRecognitionResultReady.load() ||
        m_modelRecognitionResultApplying.load() ||
        m_modelRecognitionThread.joinable()) {
        return false;
    }

    m_modelRecognitionRunning.store(true);
    try {
        m_modelRecognitionThread = std::thread(
            [this, recognitionContext, modelParam, attempt, debugParam]() {
                ModelRecognitionTaskResult taskResult;
                try {
                    if (m_shutdownRequested.load()) {
                        taskResult.message = QStringLiteral("应用正在退出");
                    }
                    QImage sourceImage;
                    QString taskError;
                    if (!taskResult.message.isEmpty()) {
                        // Do not start camera/classifier work after shutdown.
                    } else if (!CaptureModelRecognitionImage(sourceImage, taskError)) {
                        taskResult.message = taskError;
                    } else if (!CropNormalizedRoi(sourceImage,
                                                  modelParam.roiX,
                                                  modelParam.roiY,
                                                  modelParam.roiWidth,
                                                  modelParam.roiHeight,
                                                  taskResult.image,
                                                  taskError,
                                                  &taskResult.sourceRoi)) {
                        taskResult.message = taskError;
                    } else {
                        // Keep the original frame for display; only the crop
                        // above is passed to the classifier.
                        taskResult.sourceImage = sourceImage;
                        if (debugParam.enableDebug) {
                            QString savedPath;
                            QString saveError;
                            if (SaveAircraftRecognitionDebugImage(
                                    taskResult.image,
                                    debugParam,
                                    attempt,
                                    savedPath,
                                    saveError)) {
                                const QByteArray path = savedPath.toUtf8();
                                LOG_INFO("[ParkingSpaceGuide][Debug] aircraft recognition ROI image saved: %s\n",
                                         path.constData());
                            } else {
                                const QByteArray message = saveError.toUtf8();
                                LOG_WARNING("[ParkingSpaceGuide][Debug] %s\n",
                                            message.constData());
                            }
                        }
                        if (debugParam.printDetailLog) {
                            LOG_INFO("[ParkingSpaceGuide][Algorithm] AAPGS model recognition begin roiImage=%dx%d roi=(%.6f,%.6f,%.6f,%.6f) expectedModel=%s attempt=%d\n",
                                     taskResult.image.width(),
                                     taskResult.image.height(),
                                     modelParam.roiX,
                                     modelParam.roiY,
                                     modelParam.roiWidth,
                                     modelParam.roiHeight,
                                     recognitionContext.constData(),
                                     attempt);
                        }
                        ModelRecognitionResult modelResult;
                        const auto recognitionStartedAt =
                            std::chrono::steady_clock::now();
                        taskResult.returnCode =
                            m_detectPresenter->RecognizeModel2D(
                                taskResult.image,
                                recognitionContext,
                                modelResult);
                        const long long elapsedMs =
                            std::chrono::duration_cast<std::chrono::milliseconds>(
                                std::chrono::steady_clock::now() -
                                recognitionStartedAt)
                                .count();
                        taskResult.modelType = modelResult.modelType;
                        taskResult.confidence = modelResult.confidence;
                        taskResult.message = modelResult.message;
                        taskResult.verified = modelResult.verified;
                        taskResult.recognitionComplete =
                            modelResult.recognitionComplete;
                        taskResult.verificationSupported =
                            modelResult.verificationSupported;
                        taskResult.confidenceAccepted =
                            std::isfinite(modelResult.confidence) &&
                            modelResult.confidence >=
                                modelParam.confidenceThreshold;
                        taskResult.verificationAccepted =
                            modelResult.IsVerified(
                                modelParam.confidenceThreshold);
                        if (debugParam.printDetailLog) {
                            const QByteArray modelType =
                                modelResult.modelType.toUtf8();
                            const QByteArray modelMessage =
                                modelResult.message.toUtf8();
                            LOG_INFO("[ParkingSpaceGuide][Algorithm] AAPGS model recognition end ret=%d elapsedMs=%lld model=%s confidence=%.6f complete=%d supported=%d verified=%d message=%s\n",
                                     taskResult.returnCode,
                                     elapsedMs,
                                     modelType.constData(),
                                     modelResult.confidence,
                                     modelResult.recognitionComplete ? 1 : 0,
                                     modelResult.verificationSupported ? 1 : 0,
                                     modelResult.verified ? 1 : 0,
                                     modelMessage.constData());
                        }
                    }
                } catch (const std::exception& e) {
                    taskResult.message = QStringLiteral("机型识别异常：%1")
                                             .arg(QString::fromUtf8(e.what()));
                } catch (...) {
                    taskResult.message =
                        QStringLiteral("机型识别发生未知异常");
                }

                {
                    std::lock_guard<std::mutex> resultLock(
                        m_modelRecognitionMutex);
                    m_modelRecognitionTaskResult = std::move(taskResult);
                    m_modelRecognitionRunning.store(false);
                    m_modelRecognitionResultReady.store(true);
                }
                m_detectionCondition.notify_all();
            });
    } catch (...) {
        m_modelRecognitionRunning.store(false);
        errorMessage = QStringLiteral("创建机型识别任务失败");
        return false;
    }
    return true;
}

bool ParkingSpaceGuidePresenter::TakeModelRecognitionTaskResult(
    ModelRecognitionTaskResult& result)
{
    if (!m_modelRecognitionResultReady.load()) {
        return false;
    }

    std::thread completedThread;
    {
        std::lock_guard<std::mutex> lock(m_modelRecognitionMutex);
        if (!m_modelRecognitionResultReady.load()) {
            return false;
        }
        result = std::move(m_modelRecognitionTaskResult);
        m_modelRecognitionTaskResult = ModelRecognitionTaskResult();
        m_modelRecognitionResultApplying.store(true);
        m_modelRecognitionResultReady.store(false);
        if (m_modelRecognitionThread.joinable()) {
            completedThread = std::move(m_modelRecognitionThread);
        }
    }
    if (completedThread.joinable()) {
        completedThread.join();
    }
    return true;
}

void ParkingSpaceGuidePresenter::WaitForModelRecognitionTask(
    bool discardResult)
{
    std::thread worker;
    {
        std::lock_guard<std::mutex> lock(m_modelRecognitionMutex);
        if (m_modelRecognitionThread.joinable()) {
            worker = std::move(m_modelRecognitionThread);
        }
    }
    if (worker.joinable()) {
        worker.join();
    }
    if (discardResult) {
        std::lock_guard<std::mutex> lock(m_modelRecognitionMutex);
        m_modelRecognitionTaskResult = ModelRecognitionTaskResult();
        m_modelRecognitionRunning.store(false);
        m_modelRecognitionResultReady.store(false);
        m_modelRecognitionResultApplying.store(false);
    }
    m_detectionCondition.notify_all();
}

void ParkingSpaceGuidePresenter::ApplyModelRecognitionTaskResult(
    const ModelRecognitionTaskResult& taskResult,
    ParkingGuideAlgorithmState& algorithmState,
    DetectionResult& result,
    const VrModelRecognitionParam& modelParam)
{
    algorithmState.modelRecognitionInProgress = false;
    algorithmState.recognizedModelType = taskResult.modelType.trimmed();
    algorithmState.modelConfidence = taskResult.confidence;
    result.imageIsRoi = false;
    if (!taskResult.sourceImage.isNull()) {
        result.image = DrawModelRecognitionRoi(taskResult.sourceImage,
                                               taskResult.sourceRoi);
        // The UI uses this flag to bypass normal-frame coalescing so the
        // recognition frame cannot be discarded before its ROI is displayed.
        result.imageIsRoi = taskResult.sourceRoi.isValid() &&
                            !taskResult.sourceRoi.isEmpty();
    }

    const bool hasSelectedModel =
        !algorithmState.selectedModelType.trimmed().isEmpty();
    const bool requiresModelMatch =
        !DetectableModelFamily(algorithmState.selectedModelType).isEmpty();
    if ((!hasSelectedModel || !requiresModelMatch) &&
        taskResult.returnCode == 0 &&
        taskResult.recognitionComplete &&
        taskResult.confidenceAccepted) {
        algorithmState.modelRecognitionComplete = true;
        algorithmState.modelVerificationSupported = requiresModelMatch;
        algorithmState.modelVerified = false;
        if (!hasSelectedModel) {
            NotifyStatus(QStringLiteral("自动识别机型：%1，置信度%2")
                             .arg(taskResult.modelType)
                             .arg(taskResult.confidence, 0, 'f', 3)
                             .toUtf8()
                             .toStdString());
        }
        return;
    }
    if (taskResult.returnCode == 0 &&
        taskResult.verificationAccepted) {
        algorithmState.modelRecognitionComplete = true;
        algorithmState.modelVerificationSupported =
            taskResult.verificationSupported;
        algorithmState.modelVerified = true;
        return;
    }

    QString reason = taskResult.message.trimmed();
    if (reason.isEmpty() && taskResult.returnCode == 0) {
        reason = QStringLiteral("机型识别置信度不足：%1，实际%2，阈值%3")
                     .arg(taskResult.modelType)
                     .arg(taskResult.confidence, 0, 'f', 3)
                     .arg(modelParam.confidenceThreshold, 0, 'f', 3);
    }
    if (reason.isEmpty()) {
        reason = QStringLiteral("机型识别结果未通过验证");
    }
    NotifyStatus(reason.toUtf8().toStdString());
    result.message = result.message.trimmed().isEmpty()
        ? reason
        : result.message + QStringLiteral("；") + reason;

    const int maxAttempts = (std::max)(
        1, modelParam.maxRecognitionAttempts);
    if (!requiresModelMatch ||
        algorithmState.modelRecognitionAttempts < maxAttempts) {
        return;
    }
    for (ParkingSpaceGuideInfo& info : result.parkingSpaceInfoList) {
        if (MustPreserveGuideState(info.guideStateCode)) {
            continue;
        }
        info.hasException = true;
        info.guideStateCode = static_cast<int>(
            ParkingGuideState::AircraftVerificationFailed);
        info.guideText = QStringLiteral("STOP+IDFAIL");
        algorithmState.lastGuideStateCode = info.guideStateCode;
    }
}

void ParkingSpaceGuidePresenter::UpdateDetectionResultModelFields(
    DetectionResult& result,
    const ParkingGuideAlgorithmState& algorithmState) const
{
    const QString expectedModelType =
        algorithmState.selectedModelType.trimmed();
    const QString recognizedModelType =
        algorithmState.recognizedModelType.trimmed();
    for (ParkingSpaceGuideInfo& info : result.parkingSpaceInfoList) {
        info.expectedModelType = expectedModelType;
        info.modelType = recognizedModelType.isEmpty()
            ? QStringLiteral("未知")
            : recognizedModelType;
        info.modelMatched = algorithmState.modelVerified;
        info.modelVerificationSupported =
            algorithmState.modelVerificationSupported;
        info.confidence = std::isfinite(algorithmState.modelConfidence)
            ? algorithmState.modelConfidence
            : 0.0;
    }
}

void ParkingSpaceGuidePresenter::DetectionLoop(QString selectedModelType,
                                                bool automaticMode)
{
    ParkingGuideAlgorithmState algorithmState;
    algorithmState.selectedModelType =
        NormalizeSelectedModelType(selectedModelType, CurrentAircraftModels());
    unsigned long long activeSimulationRound = 0;
    bool automaticAwaitingAircraftClear = false;
    bool skipFurtherLocalization = false;
    while (!m_stopDetectionRequested.load()) {
        std::shared_ptr<const OwnedCloudFrame> cloudFrame;
        unsigned long long frameSequence = 0;
        QString lidarError;
        bool recognitionResultOnly = false;
        {
            std::unique_lock<std::mutex> dataLock(m_dataMutex);
            m_detectionCondition.wait(dataLock, [this]() {
                return m_stopDetectionRequested.load() ||
                       m_lidarErrorPending ||
                       m_modelRecognitionResultReady.load() ||
                       m_cloudSequence != m_consumedCloudSequence;
            });
            if (m_stopDetectionRequested.load()) {
                break;
            }

            if (m_lidarErrorPending) {
                lidarError = m_lidarErrorMessage;
                m_lidarErrorPending = false;
            } else if (m_cloudSequence != m_consumedCloudSequence) {
                cloudFrame = m_latestCloudFrame;
                m_consumedCloudSequence = m_cloudSequence;
                frameSequence = m_consumedCloudSequence;
            } else {
                recognitionResultOnly =
                    m_modelRecognitionResultReady.load();
            }
        }

        if (!lidarError.isEmpty()) {
            PublishErrorResult(kDeviceErrorLidar, lidarError);
            m_stopDetectionRequested.store(true);
            m_detectionRunning.store(false);
            m_trackingMode.store(false);
            NotifyWorkStatus(WorkStatus::Error);
            break;
        }
        if (!cloudFrame && !recognitionResultOnly) {
            continue;
        }

        if (cloudFrame && m_simulationOptions.enabled) {
            const unsigned long long currentRound = m_simulationRound.load();
            if (currentRound != activeSimulationRound) {
                algorithmState = ParkingGuideAlgorithmState();
                algorithmState.selectedModelType =
                    NormalizeSelectedModelType(selectedModelType,
                                               CurrentAircraftModels());
                automaticAwaitingAircraftClear = false;
                skipFurtherLocalization = false;
                m_trackingMode.store(false);
                activeSimulationRound = currentRound;
            }
        }

        if (cloudFrame) {
            try {
                if (!skipFurtherLocalization) {
                    m_trackingMode.store(true);
                    DetectOnce(cloudFrame->cloud,
                               cloudFrame->timestampMs,
                               algorithmState);
                }
            } catch (const std::exception& e) {
                PublishErrorResult(-1,
                    QStringLiteral("停机引导检测异常：%1")
                        .arg(QString::fromUtf8(e.what())));
            } catch (...) {
                PublishErrorResult(
                    -1, QStringLiteral("停机引导检测发生未知异常"));
            }
        } else {
            ModelRecognitionResultApplyGuard modelResultApplyGuard(
                m_modelRecognitionResultApplying,
                m_detectionCondition);
            ModelRecognitionTaskResult taskResult;
            if (!TakeModelRecognitionTaskResult(taskResult)) {
                continue;
            }
            modelResultApplyGuard.Activate();
            DetectionResult recognitionUpdate;
            {
                std::lock_guard<std::mutex> publishLock(m_publishMutex);
                recognitionUpdate = m_lastDetectionResult;
            }
            recognitionUpdate.message.clear();
            const VrModelRecognitionParam modelParam =
                m_configManager->GetAlgorithmParams()
                    .modelRecognitionParam;
            ApplyModelRecognitionTaskResult(taskResult,
                                            algorithmState,
                                            recognitionUpdate,
                                            modelParam);
            UpdateDetectionResultModelFields(recognitionUpdate,
                                             algorithmState);
            PublishDetectionResult(recognitionUpdate);
        }

        const VrAlgorithmParams algorithmParams =
            m_configManager->GetAlgorithmParams();
        const VrPersonDetectionParam& personParam =
            algorithmParams.personDetectionParam;
        if (!personParam.enabled &&
            algorithmState.stopPositionReached &&
            !algorithmState.dockingCompleted &&
            !m_emergencyStopLatched.load()) {
            // 不检测轮挡人员：到达停止位置后停止雷达定位，满 okHoldMs 后切到状态 9。
            skipFurtherLocalization = true;
            m_trackingMode.store(false);
            const int okHoldMs =
                (std::max)(0, algorithmParams.processParam.okHoldMs);
            NotifyStatus("飞机已到达停止位置，停止检测，等待泊位引导完成");
            bool stopRequested = m_stopDetectionRequested.load();
            if (!stopRequested && okHoldMs > 0) {
                std::unique_lock<std::mutex> dataLock(m_dataMutex);
                stopRequested = m_detectionCondition.wait_for(
                    dataLock,
                    std::chrono::milliseconds(okHoldMs),
                    [this]() {
                        return m_stopDetectionRequested.load();
                    });
            }
            if (stopRequested || m_stopDetectionRequested.load()) {
                break;
            }
            algorithmState.dockingCompleted = true;
            algorithmState.lastGuideStateCode =
                static_cast<int>(ParkingGuideState::DockingCompleted);
            DetectionResult completedResult = CreateGuideStateResult(
                ParkingGuideState::DockingCompleted,
                QStringLiteral("OK"),
                QStringLiteral("泊位引导完成"),
                true);
            UpdateDetectionResultModelFields(completedResult, algorithmState);
            PublishDetectionResult(completedResult);
        }
        const QString selectedModelType =
            algorithmState.selectedModelType.trimmed();
        const bool requiresModelMatch =
            !DetectableModelFamily(selectedModelType).isEmpty();
        const bool modelVerificationSatisfied =
            !requiresModelMatch ||
            (algorithmState.modelRecognitionComplete &&
             algorithmState.modelVerified);
        const bool wheelChockSatisfied =
            !personParam.enabled || algorithmState.chocksConfirmed;
        const bool guidanceCompleted =
            algorithmState.dockingCompleted &&
            modelVerificationSatisfied &&
            wheelChockSatisfied &&
            !m_emergencyStopLatched.load() &&
            !(m_emergencyStopEnabled.load() &&
              (!m_emergencyStopAvailable.load() ||
               m_emergencyStopActive.load()));
        const bool automaticAircraftCleared =
            automaticMode && automaticAwaitingAircraftClear &&
            algorithmState.lostFrameCount >=
                (std::max)(1,
                    algorithmParams.processParam.lostFrameThreshold);
        {
            std::lock_guard<std::mutex> dataLock(m_dataMutex);
            m_processedCloudSequence =
                (std::max)(m_processedCloudSequence, frameSequence);
            if (guidanceCompleted && !automaticMode) {
                m_stopDetectionRequested.store(true);
            }
        }
        if (guidanceCompleted && !automaticMode) {
            m_detectionRunning.store(false);
            m_trackingMode.store(false);
        }
        m_detectionCondition.notify_all();

        if (guidanceCompleted) {
            if (automaticMode) {
                if (!automaticAwaitingAircraftClear) {
                    automaticAwaitingAircraftClear = true;
                    skipFurtherLocalization = false;
                    FinishGuideSession(
                        algorithmState.lastGuideStateCode,
                        false);
                    NotifyStatus("自动检测完成一轮，持续监测并等待飞机离开");
                }
            } else {
                NotifyWorkStatus(WorkStatus::Completed);
                NotifyStatus("停机引导完成，系统已进入休眠");
                FinishGuideSession(
                    algorithmState.lastGuideStateCode,
                    false);
                break;
            }
        }
        if (automaticAircraftCleared) {
            algorithmState = ParkingGuideAlgorithmState();
            automaticAwaitingAircraftClear = false;
            skipFurtherLocalization = false;
            m_lastProbeAcceptedMs.store(0);
            m_trackingMode.store(false);
            BeginGuideSession();
            NotifyStatus("已确认上一架飞机离开，继续等待下一架飞机");
        }
    }

    m_detectionRunning.store(false);
    m_automaticDetection.store(false);
    m_trackingMode.store(false);
    if (m_simulationOptions.enabled) {
        RequestVideoStreamStop();
    }
    {
        std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
        if (m_selectedModelType.compare(selectedModelType,
                                        Qt::CaseInsensitive) == 0) {
            m_selectedModelType.clear();
        }
    }
}

int ParkingSpaceGuidePresenter::StopDetection()
{
    std::lock_guard<std::mutex> threadLock(m_detectionThreadMutex);
    const bool wasRunning = m_detectionRunning.load();
    {
        std::lock_guard<std::mutex> dataLock(m_dataMutex);
        m_stopDetectionRequested.store(true);
    }
    m_detectionCondition.notify_all();
    // 正式工作视频常开，停止检测不断流；仿真或软件退出时才关。
    const bool stopVideoStream =
        m_simulationOptions.enabled || m_shutdownRequested.load();
    if (stopVideoStream) {
        RequestVideoStreamStop();
    }

    if (m_simulationThread.joinable() &&
        m_simulationThread.get_id() != std::this_thread::get_id()) {
        m_simulationThread.join();
    }
    if (m_detectionThread.joinable() &&
        m_detectionThread.get_id() != std::this_thread::get_id()) {
        m_detectionThread.join();
    }
    if (stopVideoStream) {
        StopVideoStream();
    }
    WaitForModelRecognitionTask(true);
    m_detectionRunning.store(false);
    m_automaticDetection.store(false);
    m_trackingMode.store(false);
    m_lastProbeAcceptedMs.store(0);

    if (wasRunning) {
        FinishGuideSession(static_cast<int>(ParkingGuideState::Waiting), false);
        m_activated.store(false);
        if (!m_reconfiguring.load()) {
            NotifyWorkStatus(WorkStatus::Ready);
        }
        NotifyStatus(m_simulationOptions.enabled
            ? "停机引导仿真回放已停止"
            : "停机引导实时检测已停止");
    }
    return 0;
}

bool ParkingSpaceGuidePresenter::IsDetectionRunning() const
{
    return m_detectionRunning.load();
}

int ParkingSpaceGuidePresenter::LoadAndDetect(const QString& fileName)
{
    Q_UNUSED(fileName);
    return TriggerDetection(m_currentCameraIndex) ? 0 : -1;
}

int ParkingSpaceGuidePresenter::SaveDetectionDataToFile(const std::string& filePath)
{
    std::lock_guard<std::mutex> lock(m_dataMutex);

    std::ofstream file(filePath.c_str(), std::ios::out | std::ios::trunc);
    if (!file.is_open()) {
        return -1;
    }

    file << "ParkingSpaceGuide cached data\n";
    file << "hasFrame=" << (m_hasFrame ? 1 : 0) << "\n";
    file << "frameWidth=" << m_latestFrameInfo.width << "\n";
    file << "frameHeight=" << m_latestFrameInfo.height << "\n";
    file << "hasCloud=" << (m_latestCloudFrame ? 1 : 0) << "\n";
    file << "cloudLines=" << (m_latestCloudFrame ? m_latestCloudFrame->cloud.size() : 0) << "\n";
    return 0;
}

int ParkingSpaceGuidePresenter::GetDetectionDataCacheSize() const
{
    std::lock_guard<std::mutex> lock(m_dataMutex);
    return (m_hasFrame ? 1 : 0) + (m_latestCloudFrame ? 1 : 0);
}

bool ParkingSpaceGuidePresenter::CalibrateGround(
    VrPlaneGroundCalibrationParam& calibration,
    QString& errorMessage)
{
    errorMessage.clear();
    std::shared_ptr<const OwnedCloudFrame> cloudFrame;
    {
        std::lock_guard<std::mutex> dataLock(m_dataMutex);
        cloudFrame = m_latestCloudFrame;
    }
    if (!cloudFrame || cloudFrame->cloud.empty()) {
        errorMessage = QStringLiteral("尚未获取到可用于地面调平的雷达点云");
        return false;
    }

    std::lock_guard<std::mutex> executionLock(m_detectionExecutionMutex);
    if (!m_detectPresenter) {
        errorMessage = QStringLiteral("地面调平算法未初始化");
        return false;
    }
    return m_detectPresenter->CalibrateGround(cloudFrame->cloud,
                                               calibration,
                                               errorMessage) == 0;
}

bool ParkingSpaceGuidePresenter::CapturePreviewImage(QImage& image,
                                                      QString& errorMessage)
{
    return CaptureModelRecognitionImage(image, errorMessage);
}

void ParkingSpaceGuidePresenter::SetDefaultCameraIndex(int cameraIndex)
{
    m_currentCameraIndex = (std::max)(1, cameraIndex);
}

int ParkingSpaceGuidePresenter::GetDetectIndex() const
{
    return m_detectIndex;
}

QString ParkingSpaceGuidePresenter::GetAlgoVersion() const
{
    return DetectPresenter::GetAlgoVersion();
}

ConfigManager* ParkingSpaceGuidePresenter::GetConfigManager()
{
    return m_configManager;
}

std::vector<std::pair<std::string, void*>> ParkingSpaceGuidePresenter::GetCameraList() const
{
    return m_cameraList;
}

void ParkingSpaceGuidePresenter::OnConfigChanged(const ConfigResult& configResult)
{
    std::lock_guard<std::mutex> reconfigurationLock(m_reconfigurationMutex);
    if (m_shutdownRequested.load() || !m_initialized) {
        return;
    }

    m_reconfiguring.store(true);
    const bool ignoreEmergencyStop = configResult.debugParam.enableDebug;
    const bool emergencyStopModeChanged =
        m_emergencyStopIgnored.exchange(ignoreEmergencyStop) !=
        ignoreEmergencyStop;
    const bool emergencyStopConfigChanged = emergencyStopModeChanged ||
        !m_hasEmergencyStopConfig ||
        !SameEmergencyStopConfig(m_emergencyStopConfig,
                                 configResult.emergencyStopConfig);
    const bool remoteViewConfigChanged =
        !m_hasRemoteViewConfig ||
        !SameRemoteViewConfig(m_remoteViewConfig,
                              configResult.remoteViewConfig);
    bool restartDetection = m_detectionRunning.load();
    const bool restartAutomaticMode = m_automaticDetection.load();
    const int detectIndex = m_detectIndex;
    QString selectedModelType;
    {
        std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
        selectedModelType = m_selectedModelType;
    }
    StopDetection();
    if (m_shutdownRequested.load()) {
        return;
    }
    // 重连相机前先停推流，避免采集线程还握着即将被关闭的设备。
    if (!m_simulationOptions.enabled) {
        StopVideoStream();
    }
    if (!ignoreEmergencyStop && m_emergencyStopLatched.load()) {
        restartDetection = false;
    }
    if (emergencyStopConfigChanged) {
        if (ignoreEmergencyStop) {
            m_emergencyStopLatched.store(false);
        } else {
            // Enabling or rebuilding the GPIO monitor creates a sampling gap.
            // Do not auto-resume until the safety input is sampled again.
            m_emergencyStopLatched.store(true);
            restartDetection = false;
        }
    }
    // A callback that passed its outer reconfiguration check must finish (or
    // recheck and abort) before output objects are rebuilt. GPIO monitoring
    // itself stays alive so short emergency-stop presses remain latched.
    {
        std::lock_guard<std::mutex> safetyPublishBarrier(
            m_safetyPublishMutex);
    }

    NotifyStatus(m_simulationOptions.enabled
        ? "配置已变更，正在重新初始化输出协议"
        : "配置已变更，正在重新连接设备");
    if (!m_simulationOptions.enabled) {
        InitMvsCamera(configResult.mvsCamera);
        if (m_shutdownRequested.load()) {
            return;
        }
        InitRsLidar(configResult.lidarEnabled,
                    configResult.lidarConfig);
        if (m_shutdownRequested.load()) {
            return;
        }
    }
    InitLedDisplay(configResult.ledDisplayConfig);
    if (m_shutdownRequested.load()) {
        return;
    }
    InitUdpBroadcast(configResult.udpBroadcastConfig);
    if (m_shutdownRequested.load()) {
        return;
    }
    InitHttpServer(configResult.httpServerConfig);
    if (m_shutdownRequested.load()) {
        return;
    }
    if (remoteViewConfigChanged) {
        InitRemoteView(configResult.remoteViewConfig);
    }
    if (emergencyStopConfigChanged) {
        InitEmergencyStop(configResult.emergencyStopConfig);
    }
    InitGuideRecordStore();

    m_reconfiguring.store(false);
    // 设备重连后恢复正式工作的常开实时视频。
    StartOfficialVideoStreamIfNeeded();
    if (!PublishCurrentSafetyState(false, true) && restartDetection) {
        if (!StartDetectionInternal(selectedModelType,
                                    detectIndex,
                                    false,
                                    restartAutomaticMode)) {
            NotifyWorkStatus(WorkStatus::Error);
        }
    }
}

IYParkingSpaceGuideStatus* ParkingSpaceGuidePresenter::StatusCallback() const
{
    return static_cast<IYParkingSpaceGuideStatus*>(m_statusCallback);
}

int ParkingSpaceGuidePresenter::InitConfig()
{
    if (!m_configManager) {
        m_configManager = new ConfigManager();
    }

    if (!m_configManager->Initialize(PathManager::GetInstance().GetConfigFilePath().toStdString())) {
        NotifyStatus("初始化配置管理器失败");
        return -1;
    }

    ConfigResult config = m_configManager->GetConfigResult();
    config.Normalize();
    SystemConfig systemConfig = m_configManager->GetConfig();
    systemConfig.configResult = config;
    m_configManager->UpdateFullConfig(systemConfig);
    return 0;
}

int ParkingSpaceGuidePresenter::InitSimulationData()
{
    ClearSimulationData();

    const QFileInfo directoryInfo(m_simulationOptions.dataDirectory);
    if (!directoryInfo.exists() || !directoryInfo.isDir()) {
        NotifyStatus(QStringLiteral("仿真数据目录不存在或不是目录：%1")
                         .arg(directoryInfo.absoluteFilePath())
                         .toUtf8()
                         .toStdString());
        return -1;
    }

    const QDir directory(directoryInfo.absoluteFilePath());
    const QFileInfoList entries = directory.entryInfoList(
        QDir::Files | QDir::Readable | QDir::NoDotAndDotDot,
        QDir::Name);
    for (const QFileInfo& entry : entries) {
        const QString suffix = entry.suffix();
        if (suffix.compare(QStringLiteral("txt"), Qt::CaseInsensitive) == 0) {
            m_simulationRadarFiles.push_back(entry.absoluteFilePath());
        } else if (suffix.compare(QStringLiteral("bmp"), Qt::CaseInsensitive) == 0) {
            m_simulationCameraFiles.push_back(entry.absoluteFilePath());
        }
    }

    SortPathsNaturally(m_simulationRadarFiles);
    SortPathsNaturally(m_simulationCameraFiles);
    if (m_simulationRadarFiles.size() < 2) {
        NotifyStatus("仿真数据目录至少需要两个 TXT 雷达帧");
        ClearSimulationData();
        return -1;
    }
    if (m_simulationCameraFiles.empty()) {
        NotifyStatus("仿真数据目录至少需要一个 BMP 平面相机帧");
        ClearSimulationData();
        return -1;
    }

    NotifyStatus(QStringLiteral("开始将仿真数据加载到内存：%1 个点云，%2 个图像")
                     .arg(m_simulationRadarFiles.size())
                     .arg(m_simulationCameraFiles.size())
                     .toUtf8()
                     .toStdString());

    QString errorMessage;
    try {
        m_simulationRadarFrames.reserve(m_simulationRadarFiles.size());
        for (size_t frameIndex = 0;
             frameIndex < m_simulationRadarFiles.size();
             ++frameIndex) {
            std::shared_ptr<OwnedCloudFrame> radarFrame;
            if (!LoadSimulationRadarFrame(frameIndex,
                                          radarFrame,
                                          errorMessage)) {
                NotifyStatus(QStringLiteral("加载仿真点云失败：%1")
                                 .arg(errorMessage)
                                 .toUtf8()
                                 .toStdString());
                ClearSimulationData();
                return -1;
            }
            m_simulationRadarFrames.push_back(radarFrame);

            if (frameIndex == 0 ||
                frameIndex + 1 == m_simulationRadarFiles.size() ||
                (frameIndex + 1) % 10 == 0) {
                NotifyStatus(QStringLiteral("点云加载进度：%1/%2")
                                 .arg(frameIndex + 1)
                                 .arg(m_simulationRadarFiles.size())
                                 .toUtf8()
                                 .toStdString());
            }
        }

        m_simulationCameraFrames.reserve(m_simulationCameraFiles.size());
        for (size_t imageIndex = 0;
             imageIndex < m_simulationCameraFiles.size();
             ++imageIndex) {
            QImage cameraFrame;
            if (!LoadSimulationCameraFile(imageIndex,
                                          cameraFrame,
                                          errorMessage)) {
                NotifyStatus(QStringLiteral("加载仿真图像失败：%1")
                                 .arg(errorMessage)
                                 .toUtf8()
                                 .toStdString());
                ClearSimulationData();
                return -1;
            }
            m_simulationCameraFrames.push_back(cameraFrame);
            if (imageIndex == 0 ||
                imageIndex + 1 == m_simulationCameraFiles.size() ||
                (imageIndex + 1) % 10 == 0) {
                NotifyStatus(QStringLiteral("图像加载进度：%1/%2")
                                 .arg(imageIndex + 1)
                                 .arg(m_simulationCameraFiles.size())
                                 .toUtf8()
                                 .toStdString());
            }
        }
    } catch (const std::exception& e) {
        NotifyStatus(QStringLiteral("仿真数据加载到内存失败：%1")
                         .arg(QString::fromUtf8(e.what()))
                         .toUtf8()
                         .toStdString());
        ClearSimulationData();
        return -1;
    } catch (...) {
        NotifyStatus("仿真数据加载到内存时发生未知异常");
        ClearSimulationData();
        return -1;
    }

    {
        std::lock_guard<std::mutex> dataLock(m_dataMutex);
        m_latestCloudFrame = m_simulationRadarFrames.front();
    }
    CacheSimulationCameraFrame(0, m_simulationCameraFrames.front());

    m_cameraList.clear();
    m_cameraList.push_back(std::make_pair(
        std::string("仿真平面相机"), static_cast<void*>(nullptr)));
    NotifyCameraStatus(true);
    NotifyLidarStatus(true);
    NotifyStatus(QStringLiteral("仿真数据已全部加载到内存：%1 个点云帧，%2 个图像帧，图像循环配对，周期 %3 ms%4")
                     .arg(m_simulationRadarFrames.size())
                     .arg(m_simulationCameraFrames.size())
                     .arg(m_simulationOptions.frameIntervalMs)
                     .arg(m_simulationOptions.loop
                              ? QStringLiteral("，循环回放")
                              : QStringLiteral("，单次回放"))
                     .toUtf8()
                     .toStdString());
    return 0;
}

void ParkingSpaceGuidePresenter::ClearSimulationData()
{
    m_simulationRadarFiles.clear();
    m_simulationCameraFiles.clear();
    m_simulationRadarFrames.clear();
    m_simulationCameraFrames.clear();
    m_cameraList.clear();
    std::lock_guard<std::mutex> dataLock(m_dataMutex);
    m_simulationCameraImage = QImage();
    m_latestPreviewImage = QImage();
    m_latestFrame.clear();
    m_latestFrameInfo = CameraFrameInfo();
    m_hasFrame = false;
    m_latestCloudFrame.reset();
    for (std::shared_ptr<OwnedCloudFrame>& slot : m_cloudFrameSlots) {
        slot.reset();
    }
    m_nextCloudFrameSlot = 0;
    m_cloudSequence = 0;
    m_consumedCloudSequence = 0;
    m_processedCloudSequence = 0;
    m_lidarErrorPending = false;
    m_lidarErrorMessage.clear();
}

bool ParkingSpaceGuidePresenter::LoadSimulationRadarFrame(
    size_t frameIndex,
    std::shared_ptr<OwnedCloudFrame>& frame,
    QString& errorMessage)
{
    frame.reset();
    errorMessage.clear();
    if (frameIndex >= m_simulationRadarFiles.size()) {
        errorMessage = QStringLiteral("雷达帧序号越界：%1").arg(frameIndex);
        return false;
    }

    const QString filePath = m_simulationRadarFiles[frameIndex];
    LaserDataLoader loader;
    std::vector<std::pair<EVzResultDataType, SVzLaserLineData>> loadedData;
    int lineCount = 0;
    float scanSpeed = 0.0f;
    int maxTimestamp = 0;
    int clocksPerSecond = 0;
    int ret = -1;
    try {
        ret = loader.LoadLaserScanData(QFile::encodeName(filePath).toStdString(),
                                       loadedData,
                                       lineCount,
                                       scanSpeed,
                                       maxTimestamp,
                                       clocksPerSecond);
    } catch (const std::exception& e) {
        errorMessage = QStringLiteral("加载 %1 异常：%2")
                           .arg(QFileInfo(filePath).fileName(),
                                QString::fromUtf8(e.what()));
        loader.FreeLaserScanData(loadedData);
        return false;
    } catch (...) {
        errorMessage = QStringLiteral("加载 %1 时发生未知异常")
                           .arg(QFileInfo(filePath).fileName());
        loader.FreeLaserScanData(loadedData);
        return false;
    }
    if (ret != 0) {
        errorMessage = QStringLiteral("%1：%2")
                           .arg(QFileInfo(filePath).fileName(),
                                QString::fromStdString(loader.GetLastError()));
        loader.FreeLaserScanData(loadedData);
        return false;
    }
    if (loadedData.empty()) {
        errorMessage = QStringLiteral("%1 未包含扫描线")
                           .arg(QFileInfo(filePath).fileName());
        loader.FreeLaserScanData(loadedData);
        return false;
    }

    size_t totalPointCount = 0;
    int maximumLinePointCount = 0;
    for (const auto& item : loadedData) {
        const SVzLaserLineData& line = item.second;
        if (line.nPointCount < 0 ||
            (line.nPointCount > 0 && !line.p3DPoint)) {
            errorMessage = QStringLiteral("%1 包含无效扫描线")
                               .arg(QFileInfo(filePath).fileName());
            loader.FreeLaserScanData(loadedData);
            return false;
        }
        if (item.first != keResultDataType_Position &&
            item.first != keResultDataType_PointXYZI &&
            item.first != keResultDataType_PointXYZRGBA) {
            errorMessage = QStringLiteral("%1 的点类型不支持：%2")
                               .arg(QFileInfo(filePath).fileName())
                               .arg(static_cast<int>(item.first));
            loader.FreeLaserScanData(loadedData);
            return false;
        }

        const size_t pointCount = static_cast<size_t>(line.nPointCount);
        if (pointCount > (std::numeric_limits<size_t>::max)() - totalPointCount) {
            errorMessage = QStringLiteral("%1 的点数量溢出")
                               .arg(QFileInfo(filePath).fileName());
            loader.FreeLaserScanData(loadedData);
            return false;
        }
        totalPointCount += pointCount;
        maximumLinePointCount = (std::max)(maximumLinePointCount,
                                            line.nPointCount);
    }
    if (totalPointCount == 0) {
        errorMessage = QStringLiteral("%1 不包含有效点")
                           .arg(QFileInfo(filePath).fileName());
        loader.FreeLaserScanData(loadedData);
        return false;
    }

    try {
        std::shared_ptr<OwnedCloudFrame> converted =
            std::make_shared<OwnedCloudFrame>();
        converted->points.resize(totalPointCount);
        std::memset(converted->points.data(),
                    0,
                    sizeof(SVzNLPointXYZI) * totalPointCount);
        converted->cloud.reserve(loadedData.size());

        size_t pointOffset = 0;
        for (const auto& item : loadedData) {
            const SVzLaserLineData& sourceLine = item.second;
            SVzLaserLineData targetLine = sourceLine;
            targetLine.p2DPoint = nullptr;
            targetLine.p3DPoint = sourceLine.nPointCount > 0
                ? converted->points.data() + pointOffset
                : nullptr;

            for (int pointIndex = 0;
                 pointIndex < sourceLine.nPointCount;
                 ++pointIndex) {
                SVzNLPointXYZI& targetPoint =
                    converted->points[pointOffset + static_cast<size_t>(pointIndex)];
                if (item.first == keResultDataType_Position) {
                    const auto* sourcePoints =
                        static_cast<const SVzNL3DPosition*>(sourceLine.p3DPoint);
                    targetPoint.x = static_cast<float>(sourcePoints[pointIndex].pt3D.x);
                    targetPoint.y = static_cast<float>(sourcePoints[pointIndex].pt3D.y);
                    targetPoint.z = static_cast<float>(sourcePoints[pointIndex].pt3D.z);
                    targetPoint.intensity = 0.0f;
                } else if (item.first == keResultDataType_PointXYZRGBA) {
                    const auto* sourcePoints =
                        static_cast<const SVzNLPointXYZRGBA*>(sourceLine.p3DPoint);
                    targetPoint.x = sourcePoints[pointIndex].x;
                    targetPoint.y = sourcePoints[pointIndex].y;
                    targetPoint.z = sourcePoints[pointIndex].z;
                    targetPoint.intensity = 0.0f;
                } else {
                    const auto* sourcePoints =
                        static_cast<const SVzNLPointXYZI*>(sourceLine.p3DPoint);
                    targetPoint = sourcePoints[pointIndex];
                }
            }

            converted->cloud.emplace_back(keResultDataType_PointXYZI,
                                           targetLine);
            pointOffset += static_cast<size_t>(sourceLine.nPointCount);
        }

        converted->info.height = static_cast<uint32_t>(loadedData.size());
        converted->info.width = static_cast<uint32_t>(maximumLinePointCount);
        converted->info.isDense = false;
        frame = converted;
    } catch (const std::exception& e) {
        errorMessage = QStringLiteral("转换 %1 失败：%2")
                           .arg(QFileInfo(filePath).fileName(),
                                QString::fromUtf8(e.what()));
        loader.FreeLaserScanData(loadedData);
        return false;
    } catch (...) {
        errorMessage = QStringLiteral("转换 %1 时发生未知异常")
                           .arg(QFileInfo(filePath).fileName());
        loader.FreeLaserScanData(loadedData);
        return false;
    }

    loader.FreeLaserScanData(loadedData);
    return true;
}

bool ParkingSpaceGuidePresenter::LoadSimulationCameraFile(
    size_t imageIndex,
    QImage& image,
    QString& errorMessage)
{
    image = QImage();
    errorMessage.clear();
    if (imageIndex >= m_simulationCameraFiles.size()) {
        errorMessage = QStringLiteral("图像帧序号越界：%1").arg(imageIndex);
        return false;
    }

    const QString filePath = m_simulationCameraFiles[imageIndex];
    QImageReader reader(filePath, "bmp");
    reader.setAutoTransform(true);
    image = reader.read();
    if (image.isNull()) {
        errorMessage = QStringLiteral("%1：%2")
                           .arg(QFileInfo(filePath).fileName(),
                                reader.errorString());
        return false;
    }
    if (image.format() != QImage::Format_RGB888) {
        image = image.convertToFormat(QImage::Format_RGB888);
    }
    if (image.isNull()) {
        errorMessage = QStringLiteral("%1 转换为 RGB888 失败")
                           .arg(QFileInfo(filePath).fileName());
        return false;
    }
    return true;
}

void ParkingSpaceGuidePresenter::CacheSimulationCameraFrame(
    size_t frameIndex,
    const QImage& image)
{
    const QImage rgbImage = image.format() == QImage::Format_RGB888
        ? image
        : image.convertToFormat(QImage::Format_RGB888);

    CameraFrameInfo frameInfo;
    frameInfo.width = rgbImage.width();
    frameInfo.height = rgbImage.height();
    frameInfo.pixelFormat = kMvsPixelTypeRGB8;
    frameInfo.frameId = static_cast<unsigned long long>(frameIndex + 1);
    frameInfo.timestamp = static_cast<unsigned long long>(
        QDateTime::currentMSecsSinceEpoch());

    std::lock_guard<std::mutex> dataLock(m_dataMutex);
    m_simulationCameraImage = rgbImage;
    m_latestPreviewImage = rgbImage;
    m_latestFrame.clear();
    m_latestFrameInfo = frameInfo;
    m_hasFrame = !rgbImage.isNull();
}

int ParkingSpaceGuidePresenter::InitMvsCamera(const MvsCameraConfig& config)
{
    auto closeMvsDevice = [this]() {
        if (!m_mvsDevice) {
            return;
        }

        m_mvsDevice->StopAcquisition();
        m_mvsDevice->UnregisterImageCallback();
        m_mvsDevice->CloseDevice();
        m_mvsDevice->UninitSDK();
        delete m_mvsDevice;
        m_mvsDevice = nullptr;
    };

    closeMvsDevice();
    m_cameraList.clear();
    {
        std::lock_guard<std::mutex> lock(m_dataMutex);
        m_latestFrame.clear();
        m_latestFrameInfo = CameraFrameInfo();
        m_latestPreviewImage = QImage();
        m_hasFrame = false;
    }

    if (!config.enabled) {
        NotifyCameraStatus(false);
        NotifyStatus("平面相机未启用");
        m_cameraList.push_back(std::make_pair(std::string("平面相机"), static_cast<void*>(nullptr)));
        return 0;
    }

    if (IMvsDevice::CreateObject(&m_mvsDevice) != 0 || !m_mvsDevice) {
        NotifyCameraStatus(false);
        NotifyStatus("创建平面相机设备失败");
        return -1;
    }

    int ret = m_mvsDevice->InitSDK();
    if (ret != 0) {
        NotifyCameraStatus(false);
        NotifyStatus("平面相机SDK初始化失败：" + std::to_string(ret));
        closeMvsDevice();
        return ret;
    }

    std::vector<MvsDeviceInfo> devices;
    ret = m_mvsDevice->EnumerateDevices(devices);
    CacheCameraPingAddress(config, devices);
    if (ret != 0 || devices.empty()) {
        const QString pingIp = CameraPingAddress(config);
        NotifyStatus(ret != 0
            ? "搜索平面相机失败：" + std::to_string(ret)
            : "未搜索到平面相机");
        if (IsPingableIpv4(pingIp)) {
            NotifyStatus(QStringLiteral("改用配置的相机IP进行ping：%1")
                             .arg(pingIp)
                             .toUtf8()
                             .toStdString());
        } else {
            NotifyStatus("平面相机无可用IP，请在相机设置中填写相机IP");
        }
        closeMvsDevice();
        return ret != 0 ? ret : -1;
    }

    NotifyStatus("搜索到平面相机数量：" + std::to_string(devices.size()));
    {
        const QString pingIp = CameraPingAddress(config);
        if (IsPingableIpv4(pingIp)) {
            NotifyStatus(QStringLiteral("平面相机ping地址：%1")
                             .arg(pingIp)
                             .toUtf8()
                             .toStdString());
        } else {
            NotifyStatus("平面相机未拿到IP，请在相机设置中填写相机IP");
        }
    }

    if (!config.serialNumber.empty()) {
        ret = m_mvsDevice->OpenDevice(config.serialNumber);
    } else {
        unsigned int deviceIndex = static_cast<unsigned int>((std::max)(0, config.deviceIndex));
        if (deviceIndex >= devices.size()) {
            NotifyStatus("相机设备序号超出范围，使用第0台设备");
            deviceIndex = 0;
        }
        ret = m_mvsDevice->OpenDeviceByIndex(deviceIndex);
    }

    if (ret != 0) {
        NotifyCameraStatus(false);
        NotifyStatus("打开平面相机失败：" + std::to_string(ret));
        closeMvsDevice();
        return ret;
    }

    MvsDeviceInfo openedInfo;
    std::string cameraName = config.serialNumber.empty() ? std::string("相机") : config.serialNumber;
    if (m_mvsDevice->GetDeviceInfo(openedInfo) == 0) {
        if (!openedInfo.displayName.empty()) {
            cameraName = openedInfo.displayName;
        } else if (!openedInfo.serialNumber.empty()) {
            cameraName = openedInfo.serialNumber;
        }
        if (IsPingableIpv4(QString::fromStdString(openedInfo.ipAddress))) {
            std::lock_guard<std::mutex> lock(m_pingAddressMutex);
            m_cameraPingAddress = QString::fromStdString(openedInfo.ipAddress).trimmed();
        }
    }
    ret = m_mvsDevice->SetEnumFeature("AcquisitionMode", kMvsAcqModeContinuous);
    if (ret != 0) {
        NotifyStatus("设置平面相机连续采集模式失败，继续使用当前模式：" + std::to_string(ret));
    }

    ret = m_mvsDevice->SetEnumFeature("PixelFormat", kMvsPixelTypeMono8);
    if (ret != 0) {
        NotifyStatus("设置平面相机灰度格式失败，继续使用当前格式：" + std::to_string(ret));
    }

    int streamFps = kOfficialVideoMaxFps;
    if (m_configManager) {
        streamFps = OfficialVideoFps(
            m_configManager->GetConfigResult().httpFlvStreamConfig.fps);
    }
    const double cameraFrameRate =
        OfficialCameraFrameRate(config.frameRate, streamFps);
    if (cameraFrameRate + 0.01 < config.frameRate) {
        NotifyStatus(
            QStringLiteral("平面相机采集帧率已限制为 %1 fps，避免占用网卡影响雷达")
                .arg(cameraFrameRate, 0, 'f', 2)
                .toUtf8()
                .toStdString());
    }
    ret = m_mvsDevice->SetFrameRate(cameraFrameRate);
    if (ret != 0) {
        NotifyStatus(
            "设置平面相机帧率失败，继续使用相机当前帧率：" +
            std::to_string(ret));
    } else {
        double actualFrameRate = 0.0;
        const int getFrameRateRet =
            m_mvsDevice->GetFrameRate(actualFrameRate);
        NotifyStatus(
            getFrameRateRet == 0
                ? QStringLiteral("平面相机帧率已设置：%1 fps")
                      .arg(actualFrameRate, 0, 'f', 2)
                      .toUtf8()
                      .toStdString()
                : QStringLiteral("平面相机帧率设置请求已发送：%1 fps")
                      .arg(cameraFrameRate, 0, 'f', 2)
                      .toUtf8()
                      .toStdString());
    }

    if (config.autoExposureEnabled) {
        const int exposureAutoRet =
            m_mvsDevice->SetEnumFeatureByString("ExposureAuto", "Off");
        const int gainAutoRet =
            m_mvsDevice->SetEnumFeatureByString("GainAuto", "Off");
        if (exposureAutoRet != 0 || gainAutoRet != 0) {
            NotifyStatus(
                QStringLiteral(
                    "关闭相机内置自动曝光/增益失败：exposureRet=%1，gainRet=%2，"
                    "固定ROI曝光仍会尝试运行")
                    .arg(exposureAutoRet)
                    .arg(gainAutoRet)
                    .toUtf8()
                    .toStdString());
        }
    }

    ret = m_mvsDevice->SetTriggerMode(false);
    if (ret == 0) {
        m_cameraNeedsSoftTrigger.store(false);
        NotifyStatus("平面相机已切换为连续采集，实时视频常开");
    } else {
        // 部分相机关不掉触发时，推流线程自己发软触发，检测仍只读缓存帧。
        NotifyStatus(
            "关闭平面相机触发模式失败，实时视频回退软触发：" +
            std::to_string(ret));
        m_cameraNeedsSoftTrigger.store(true);
        ret = m_mvsDevice->SetTriggerMode(true);
        if (ret != 0) {
            NotifyCameraStatus(false);
            NotifyStatus("启用平面相机触发模式失败：" + std::to_string(ret));
            closeMvsDevice();
            return ret;
        }
        ret = m_mvsDevice->SetEnumFeatureByString("TriggerSource", "Software");
        if (ret != 0) {
            NotifyCameraStatus(false);
            NotifyStatus("设置平面相机软触发源失败：" + std::to_string(ret));
            closeMvsDevice();
            return ret;
        }
    }

    ret = m_mvsDevice->StartAcquisition();
    if (ret != 0) {
        NotifyCameraStatus(false);
        NotifyStatus("启动平面相机采集失败：" + std::to_string(ret));
        closeMvsDevice();
        return ret;
    }

    // 开机时先亮相机在线，真正心跳仍看出帧。看门狗重连成功后等第一帧再标在线，
    // 避免无图却把相机刷回在线，把双设备离线文案盖成只报雷达。
    if (!m_initialized.load()) {
        NotifyCameraStatus(true);
        MarkCameraFrameAlive();
    }
    m_cameraList.push_back(std::make_pair(cameraName, static_cast<void*>(m_mvsDevice)));
    NotifyStatus("平面相机已连接：" + cameraName);
    return 0;
}

int ParkingSpaceGuidePresenter::InitRsLidar(
    bool enabled,
    const RsLidarConfig& config)
{
    if (m_lidarDevice) {
        m_lidarDevice->Stop();
        m_lidarDevice->CloseDevice();
        delete m_lidarDevice;
        m_lidarDevice = nullptr;
    }

    {
        std::lock_guard<std::mutex> dataLock(m_dataMutex);
        m_latestCloudFrame.reset();
        for (std::shared_ptr<OwnedCloudFrame>& slot : m_cloudFrameSlots) {
            slot.reset();
        }
        m_nextCloudFrameSlot = 0;
        m_cloudSequence = 0;
        m_consumedCloudSequence = 0;
        m_processedCloudSequence = 0;
        m_lidarErrorPending = false;
        m_lidarErrorMessage.clear();
    }
    m_trackingMode.store(false);
    m_lastProbeAcceptedMs.store(0);
    m_cloudCopyErrorReported.store(false);

    if (!enabled) {
        NotifyLidarStatus(false);
        NotifyStatus("雷达未启用");
        return 0;
    }

    if (IRsLidarDevice::CreateObject(&m_lidarDevice) != 0 || !m_lidarDevice) {
        NotifyLidarStatus(false);
        return -1;
    }

    m_lidarDevice->SetPointCloudCallback([this](const RsCloudData& cloud, const RsFrameInfo& info) {
        // 未引导会 1 秒只吃一包；丢掉的包也刷新心跳，避免雷达仍在出数却被 8 秒看门狗判离线。
        MarkLidarFrameAlive();
        if (!m_trackingMode.load()) {
            const long long nowMs = SteadyClockMs();
            const long long lastMs = m_lastProbeAcceptedMs.load();
            if (lastMs > 0 && nowMs - lastMs < kAirplaneProbeIntervalMs) {
                return;
            }
            m_lastProbeAcceptedMs.store(nowMs);
        }

        SubmitCloudFrame(cloud, info);
    });

    m_lidarDevice->SetExceptionCallback([this](const RsExceptionInfo& info) {
        const QString message = info.message.empty()
            ? QStringLiteral("雷达异常")
            : QStringLiteral("雷达异常：%1").arg(QString::fromStdString(info.message));
        const bool fatal = info.code == 0x40 || info.code >= 0x80;
        if (fatal && m_detectionRunning.load()) {
            std::lock_guard<std::mutex> dataLock(m_dataMutex);
            m_lidarErrorPending = true;
            m_lidarErrorMessage = message;
        }
        if (fatal) {
            m_detectionCondition.notify_all();
        }
        NotifyStatus(message.toUtf8().toStdString());
        if (fatal) {
            // 致命异常后不再信任旧连接，让看门狗尽快重连。
            m_lastLidarFrameMs.store(0);
            NotifyLidarStatus(false);
        }
    });

    int ret = m_lidarDevice->InitDevice();
    if (ret != 0) {
        NotifyLidarStatus(false);
        return ret;
    }

    ret = m_lidarDevice->OpenDevice(config);
    if (ret != 0) {
        NotifyLidarStatus(false);
        return ret;
    }

    ret = m_lidarDevice->Start();
    NotifyLidarStatus(ret == 0);
    if (ret == 0) {
        MarkLidarFrameAlive();
    }
    return ret;
}

int ParkingSpaceGuidePresenter::InitLedDisplay(const LedDisplayConfig& config)
{
    if (m_ledDisplay) {
        m_ledDisplay->Close();
        delete m_ledDisplay;
        m_ledDisplay = nullptr;
    }

    if (ILedDisplayDevice::CreateObject(&m_ledDisplay) != 0 || !m_ledDisplay) {
        NotifyLedStatus(false);
        return -1;
    }

    m_ledDisplay->SetStatusCallback([](ELedDisplayStatus status,
                                       const std::string& message,
                                       void* user) {
        auto* self = static_cast<ParkingSpaceGuidePresenter*>(user);
        if (!self) {
            return;
        }
        self->NotifyLedStatus(status == ELedDisplayStatus::Connected);
        if (!message.empty()) {
            self->NotifyStatus(std::string("显示屏：") + message);
        }
    }, this);

    const int ret = m_ledDisplay->Open(config);
    NotifyLedStatus(config.enabled && ret == 0 && m_ledDisplay->IsConnected());
    return ret;
}

int ParkingSpaceGuidePresenter::InitUdpBroadcast(const UdpBroadcastConfig& config)
{
    std::lock_guard<std::mutex> lock(m_udpMutex);

    if (m_udpClient) {
        m_udpClient->StopUDPClient();
        delete m_udpClient;
        m_udpClient = nullptr;
    }

    m_udpBroadcastConfig = config;
    if (!config.enabled) {
        NotifyStatus("组播未启用");
        return 0;
    }

    if (config.address.empty() || config.port <= 0 || config.port > 65535) {
        NotifyStatus("组播配置无效");
        return -1;
    }

    if (!IYUDPClient::CreateUDPClient(&m_udpClient) || !m_udpClient) {
        NotifyStatus("创建组播客户端失败");
        return -1;
    }

    const int ret = m_udpClient->Init(false);
    if (ret != 0) {
        NotifyStatus("初始化组播客户端失败：" + std::to_string(ret));
        m_udpClient->StopUDPClient();
        delete m_udpClient;
        m_udpClient = nullptr;
        return ret;
    }

    NotifyStatus("组播客户端已初始化");
    return 0;
}

int ParkingSpaceGuidePresenter::InitHttpServer(const HttpServerConfig& config)
{
    CloseHttpServer();

    m_httpServer = new ParkingStatusHttpServer();
    const int ret = m_httpServer->Start(
        config,
        [this]() {
            return CurrentStatusJson();
        });
    if (ret != 0) {
        const std::string error = m_httpServer->LastError();
        delete m_httpServer;
        m_httpServer = nullptr;
        NotifyStatus(error.empty() ? "HTTP状态服务启动失败" : "HTTP状态服务启动失败：" + error);
        return ret;
    }

    if (config.enabled) {
        NotifyStatus("HTTP状态服务已启动：" + config.address + ":" + std::to_string(config.port));
    } else {
        NotifyStatus("HTTP状态服务未启用");
    }
    return 0;
}

int ParkingSpaceGuidePresenter::InitRemoteView(const RemoteViewConfig& config)
{
    if (m_shutdownRequested.load()) {
        return -1;
    }
    if (QThread::currentThread() != thread()) {
        const bool invoked = QMetaObject::invokeMethod(
            this,
            [this, config]() {
                if (!m_shutdownRequested.load()) {
                    InitRemoteView(config);
                }
            },
            Qt::QueuedConnection);
        if (!invoked) {
            NotifyStatus("无法切换到Qt主线程初始化远程显示服务");
            return -1;
        }
        return 0;
    }

    CloseRemoteView();
    m_remoteViewConfig = config;
    m_hasRemoteViewConfig = true;
    if (!config.enabled) {
        NotifyStatus("远程显示服务未启用");
        return 0;
    }

    m_remoteServer = new ParkingSpaceGuideRemoteServer(this);
    ParkingSpaceGuideRemoteServer::ControlHandlers handlers;
    handlers.modelHandler = [this](const QString& modelType) {
        return SelectModel(modelType);
    };
    handlers.startHandler = [this](const QString& modelType) {
        return StartDetection(modelType, -1);
    };
    handlers.stopHandler = [this]() {
        return StopDetection();
    };
    handlers.statusProvider = [this]() {
        return CurrentStatusJson();
    };
    handlers.runningProvider = [this]() {
        return IsDetectionRunning();
    };
    handlers.activatedProvider = [this]() {
        return m_activated.load();
    };
    handlers.workModeProvider = [this]() {
        return m_maintenanceMode.load()
            ? QStringLiteral("maintenance")
            : QStringLiteral("normal");
    };
    handlers.logHandler = [this](const QString& message) {
        NotifyStatus(message.toUtf8().toStdString());
    };
    handlers.passwordHandler = [this](const QString& password) {
        return ValidateControlPassword(password);
    };
    handlers.maintenanceHandler = [this](bool enabled) {
        return SetMaintenanceMode(enabled);
    };
    handlers.chockHandler = [this](bool chockOn) {
        return RecordManualChock(chockOn);
    };
    handlers.panelConfigProvider = [this]() {
        return ControlPanelConfigJson();
    };
    handlers.sessionsProvider = [this](int limit) {
        return ListGuideSessions(limit);
    };
    handlers.samplesProvider = [this](const QString& sessionUuid) {
        return ListGuideSamples(sessionUuid);
    };
    handlers.modelValidator = [this](const QString& modelType) {
        return IsSelectableModel(modelType);
    };
    const bool started = m_remoteServer->Start(config, std::move(handlers));
    if (!started) {
        const QString error = m_remoteServer->LastError();
        delete m_remoteServer;
        m_remoteServer = nullptr;
        NotifyStatus((error.isEmpty()
            ? QStringLiteral("远程显示服务启动失败")
            : error).toUtf8().toStdString());
        return -1;
    }

    NotifyStatus(QStringLiteral(
        "远程显示服务已启动：UDP %1，控制 %2，发布 %3")
        .arg(config.discoveryPort)
        .arg(config.controlPort)
        .arg(config.publishPort)
        .toUtf8()
        .toStdString());
    return 0;
}

int ParkingSpaceGuidePresenter::InitEmergencyStop(
    const EmergencyStopConfig& config)
{
    m_emergencyStopConfig = config;
    m_hasEmergencyStopConfig = true;
    if (m_emergencyStopIgnored.load()) {
        CloseEmergencyStop(true);
        NotifyStatus("Debug mode: emergency-stop input is ignored");
        return 0;
    }

    CloseEmergencyStop(false);
    const bool preserveLatch = m_emergencyStopLatched.load();

#if defined(Q_OS_LINUX) && defined(__aarch64__)
    {
        std::lock_guard<std::mutex> safetyLock(m_safetyMutex);
        m_emergencyStopEnabled.store(config.enabled);
        m_emergencyStopAvailable.store(!config.enabled);
        m_emergencyStopActive.store(false);
        m_emergencyStopLatched.store(preserveLatch);
    }
    if (!config.enabled) {
        NotifyStatus("急停输入未启用");
        return 0;
    }

    GpioInputConfig gpioConfig;
    gpioConfig.directionPath = config.directionPath;
    gpioConfig.valuePath = config.valuePath;
    gpioConfig.activeLow = false;
    gpioConfig.pollIntervalMs = config.pollIntervalMs;
    gpioConfig.debounceMs = config.debounceMs;
    gpioConfig.reconnectIntervalMs = config.reconnectIntervalMs;
    m_emergencyStopInput.reset(new GpioInput());
    const bool started = m_emergencyStopInput->Start(
        gpioConfig,
        [this](bool active) {
            HandleEmergencyStopChanged(active);
        },
        [this](bool available, const std::string& message) {
            HandleEmergencyStopStatus(available, message);
        });
    if (!started) {
        std::lock_guard<std::mutex> safetyLock(m_safetyMutex);
        m_emergencyStopAvailable.store(false);
        m_emergencyStopLatched.store(true);
        return -1;
    }

    return m_emergencyStopAvailable.load() ? 0 : -1;
#else
    Q_UNUSED(config);
    {
        std::lock_guard<std::mutex> safetyLock(m_safetyMutex);
        m_emergencyStopEnabled.store(false);
        m_emergencyStopAvailable.store(true);
        m_emergencyStopActive.store(false);
        m_emergencyStopLatched.store(preserveLatch);
    }
    NotifyStatus("当前平台不启用板载急停GPIO监控");
    return 0;
#endif
}

void ParkingSpaceGuidePresenter::CloseEmergencyStop(bool clearLatch)
{
    if (m_emergencyStopInput) {
        m_emergencyStopInput->Stop();
        m_emergencyStopInput.reset();
    }

    std::lock_guard<std::mutex> safetyLock(m_safetyMutex);
    m_emergencyStopEnabled.store(false);
    m_emergencyStopAvailable.store(true);
    m_emergencyStopActive.store(false);
    if (clearLatch) {
        m_emergencyStopLatched.store(false);
    }
}

void ParkingSpaceGuidePresenter::CloseUdpBroadcast()
{
    std::lock_guard<std::mutex> lock(m_udpMutex);
    if (!m_udpClient) {
        return;
    }

    LOG_INFO("[ParkingSpaceGuide][Shutdown] UDP stop begin\n");
    m_udpClient->StopUDPClient();
    delete m_udpClient;
    m_udpClient = nullptr;
    LOG_INFO("[ParkingSpaceGuide][Shutdown] UDP stop complete\n");
}

void ParkingSpaceGuidePresenter::CloseHttpServer()
{
    if (!m_httpServer) {
        return;
    }

    LOG_INFO("[ParkingSpaceGuide][Shutdown] HTTP stop begin\n");
    m_httpServer->Stop();
    delete m_httpServer;
    m_httpServer = nullptr;
    LOG_INFO("[ParkingSpaceGuide][Shutdown] HTTP stop complete\n");
}

void ParkingSpaceGuidePresenter::CloseRemoteView()
{
    if (!m_remoteServer) {
        return;
    }
    LOG_INFO("[ParkingSpaceGuide][Shutdown] Remote stop begin\n");
    m_remoteServer->Stop();
    delete m_remoteServer;
    m_remoteServer = nullptr;
    LOG_INFO("[ParkingSpaceGuide][Shutdown] Remote stop complete\n");
}

void ParkingSpaceGuidePresenter::CloseDevices()
{
    LOG_INFO("[ParkingSpaceGuide][Shutdown] Emergency stop close begin\n");
    CloseEmergencyStop();
    LOG_INFO("[ParkingSpaceGuide][Shutdown] Emergency stop close complete\n");
    CloseHttpServer();
    CloseUdpBroadcast();

    if (m_mvsDevice) {
        LOG_INFO("[ParkingSpaceGuide][Shutdown] MVS close begin\n");
        m_mvsDevice->StopAcquisition();
        m_mvsDevice->UnregisterImageCallback();
        m_mvsDevice->CloseDevice();
        m_mvsDevice->UninitSDK();
        delete m_mvsDevice;
        m_mvsDevice = nullptr;
        LOG_INFO("[ParkingSpaceGuide][Shutdown] MVS close complete\n");
    }

    if (m_lidarDevice) {
        LOG_INFO("[ParkingSpaceGuide][Shutdown] lidar close begin\n");
        m_lidarDevice->Stop();
        m_lidarDevice->CloseDevice();
        delete m_lidarDevice;
        m_lidarDevice = nullptr;
        LOG_INFO("[ParkingSpaceGuide][Shutdown] lidar close complete\n");
    }

    if (m_ledDisplay) {
        LOG_INFO("[ParkingSpaceGuide][Shutdown] LED close begin\n");
        m_ledDisplay->Close();
        delete m_ledDisplay;
        m_ledDisplay = nullptr;
        LOG_INFO("[ParkingSpaceGuide][Shutdown] LED close complete\n");
    }

    if (m_simulationOptions.enabled) {
        ClearSimulationData();
    }
}

void ParkingSpaceGuidePresenter::MarkCameraFrameAlive()
{
    m_lastCameraFrameMs.store(SteadyClockMs());
}

void ParkingSpaceGuidePresenter::MarkLidarFrameAlive()
{
    m_lastLidarFrameMs.store(SteadyClockMs());
}

void ParkingSpaceGuidePresenter::CacheCameraPingAddress(
    const MvsCameraConfig& config,
    const std::vector<MvsDeviceInfo>& devices)
{
    QString searched;
    const QString serial = QString::fromStdString(config.serialNumber).trimmed();
    if (!serial.isEmpty()) {
        for (const MvsDeviceInfo& device : devices) {
            if (QString::fromStdString(device.serialNumber).trimmed() == serial &&
                IsPingableIpv4(QString::fromStdString(device.ipAddress))) {
                searched = QString::fromStdString(device.ipAddress).trimmed();
                break;
            }
        }
    }
    if (searched.isEmpty() && !devices.empty()) {
        unsigned int deviceIndex =
            static_cast<unsigned int>((std::max)(0, config.deviceIndex));
        if (deviceIndex >= devices.size()) {
            deviceIndex = 0;
        }
        const QString ip =
            QString::fromStdString(devices[deviceIndex].ipAddress).trimmed();
        if (IsPingableIpv4(ip)) {
            searched = ip;
        }
    }

    const QString configured =
        QString::fromStdString(config.ipAddress).trimmed();
    std::lock_guard<std::mutex> lock(m_pingAddressMutex);
    if (!searched.isEmpty()) {
        m_cameraPingAddress = searched;
    } else if (IsPingableIpv4(configured)) {
        m_cameraPingAddress = configured;
    }
}

QString ParkingSpaceGuidePresenter::CameraPingAddress(
    const MvsCameraConfig& config) const
{
    const QString searched = [this]() {
        std::lock_guard<std::mutex> lock(m_pingAddressMutex);
        return m_cameraPingAddress;
    }();
    if (IsPingableIpv4(searched)) {
        return searched;
    }
    const QString configured =
        QString::fromStdString(config.ipAddress).trimmed();
    if (IsPingableIpv4(configured)) {
        return configured;
    }
    return QString();
}

QString ParkingSpaceGuidePresenter::LidarPingAddress(
    const RsLidarConfig& config) const
{
    const QString deviceIp = QString::fromStdString(config.deviceIp).trimmed();
    if (IsPingableIpv4(deviceIp)) {
        return deviceIp;
    }
    const QString host = QString::fromStdString(config.hostAddress).trimmed();
    if (IsPingableIpv4(host)) {
        return host;
    }
    return QString();
}

bool ParkingSpaceGuidePresenter::IsMvsCameraHandleReady()
{
    return m_mvsDevice &&
           m_mvsDevice->IsDeviceOpen() &&
           m_mvsDevice->IsAcquisitioning();
}

bool ParkingSpaceGuidePresenter::IsLidarHandleReady()
{
    return m_lidarDevice && m_lidarDevice->IsRunning();
}

void ParkingSpaceGuidePresenter::StartDeviceWatchdog()
{
    if (m_simulationOptions.enabled) {
        return;
    }

    StopDeviceWatchdog();
    m_deviceWatchdogStop.store(false);
    try {
        m_deviceWatchdogThread = std::thread(
            &ParkingSpaceGuidePresenter::DeviceWatchdogLoop, this);
    } catch (...) {
        NotifyStatus("设备状态监视线程启动失败");
    }
}

void ParkingSpaceGuidePresenter::StopDeviceWatchdog()
{
    m_deviceWatchdogStop.store(true);
    m_deviceWatchdogCondition.notify_all();
    if (m_deviceWatchdogThread.joinable() &&
        m_deviceWatchdogThread.get_id() != std::this_thread::get_id()) {
        m_deviceWatchdogThread.join();
    }
}

void ParkingSpaceGuidePresenter::DeviceWatchdogLoop()
{
    long long lastCameraReconnectMs = 0;
    long long lastLidarReconnectMs = 0;
    int cameraPingFailCount = 0;
    int lidarPingFailCount = 0;
    while (!m_deviceWatchdogStop.load() && !m_shutdownRequested.load()) {
        {
            std::unique_lock<std::mutex> lock(m_deviceWatchdogMutex);
            m_deviceWatchdogCondition.wait_for(
                lock,
                std::chrono::milliseconds(kDeviceWatchdogIntervalMs),
                [this]() {
                    return m_deviceWatchdogStop.load() ||
                           m_shutdownRequested.load();
                });
        }
        if (m_deviceWatchdogStop.load() || m_shutdownRequested.load()) {
            break;
        }
        if (!m_initialized.load() || m_reconfiguring.load() || !m_configManager) {
            continue;
        }

        const ConfigResult config = m_configManager->GetConfigResult();
        const long long nowMs = SteadyClockMs();
        bool cameraOnline = !config.mvsCamera.enabled;
        bool lidarOnline = !config.lidarEnabled;

        // 在线只认 ICMP ping。相机优先用搜索到的 GigE IP，没有则用相机设置里的 IP。
        // 雷达 hostAddress 是本机监听地址，通常是 0.0.0.0，改为 ping 雷达设备 IP。
        if (config.mvsCamera.enabled) {
            const QString cameraIp = CameraPingAddress(config.mvsCamera);
            if (!IsPingableIpv4(cameraIp)) {
                cameraPingFailCount = kDevicePingFailCount;
                cameraOnline = false;
            } else if (PingIpv4(cameraIp, kDevicePingTimeoutMs)) {
                cameraPingFailCount = 0;
                cameraOnline = true;
            } else {
                ++cameraPingFailCount;
                cameraOnline = cameraPingFailCount < kDevicePingFailCount;
            }
        }

        if (config.lidarEnabled) {
            const QString lidarIp = LidarPingAddress(config.lidarConfig);
            if (!IsPingableIpv4(lidarIp)) {
                lidarPingFailCount = kDevicePingFailCount;
                lidarOnline = false;
            } else if (PingIpv4(lidarIp, kDevicePingTimeoutMs)) {
                lidarPingFailCount = 0;
                lidarOnline = true;
            } else {
                ++lidarPingFailCount;
                lidarOnline = lidarPingFailCount < kDevicePingFailCount;
            }
        }

        const bool cameraOfflineConfirmed =
            config.mvsCamera.enabled && !cameraOnline;
        const bool lidarOfflineConfirmed =
            config.lidarEnabled && !lidarOnline;
        const bool cameraNewlyOffline =
            cameraOfflineConfirmed && m_cameraConnected.load();
        const bool lidarNewlyOffline =
            lidarOfflineConfirmed && m_lidarConnected.load();
        const bool cameraNewlyOnline =
            cameraOnline && config.mvsCamera.enabled &&
            !m_cameraConnected.load();
        const bool lidarNewlyOnline =
            lidarOnline && config.lidarEnabled &&
            !m_lidarConnected.load();

        if (config.mvsCamera.enabled) {
            NotifyCameraStatus(cameraOnline, false);
        }
        if (config.lidarEnabled) {
            NotifyLidarStatus(lidarOnline, false);
        }
        if (cameraNewlyOffline || lidarNewlyOffline) {
            ApplySystemErrorForOfflineDevice();
        }

        // ping 通只说明网口在，GigE 搜索可能还没恢复。句柄没打开时先重搜重连，
        // 打开成功后再自检，避免“ping 正常、自检失败：相机”。
        bool reconnectStarted = false;
        bool cameraReopened = false;
        bool lidarReopened = false;
        if (config.mvsCamera.enabled) {
            const bool cameraNeedsOpen =
                cameraOnline && !IsMvsCameraHandleReady();
            if (cameraNeedsOpen && cameraNewlyOnline) {
                lastCameraReconnectMs = 0;
            }
            const int cameraRetryMs = cameraNeedsOpen
                ? kCameraRediscoverIntervalMs
                : kDeviceReconnectIntervalMs;
            if ((cameraNeedsOpen || cameraOfflineConfirmed) &&
                nowMs - lastCameraReconnectMs >= cameraRetryMs) {
                std::unique_lock<std::mutex> cameraLock(
                    m_cameraCaptureMutex, std::try_to_lock);
                std::unique_lock<std::mutex> reconfigLock(
                    m_reconfigurationMutex, std::try_to_lock);
                if (cameraLock.owns_lock() &&
                    reconfigLock.owns_lock() &&
                    !m_reconfiguring.load() &&
                    !m_shutdownRequested.load() &&
                    !m_deviceWatchdogStop.load()) {
                    lastCameraReconnectMs = nowMs;
                    NotifyStatus(
                        cameraNeedsOpen
                            ? std::string("平面相机已恢复，正在重新搜索并连接")
                            : (DeviceOfflineMessage() +
                               QStringLiteral("，正在尝试重新连接平面相机"))
                                  .toUtf8()
                                  .toStdString());
                    cameraReopened = InitMvsCamera(config.mvsCamera) == 0 &&
                                     IsMvsCameraHandleReady();
                    reconnectStarted = true;
                }
            }
        }

        if (!reconnectStarted && config.lidarEnabled) {
            const bool lidarNeedsOpen =
                lidarOnline && !IsLidarHandleReady();
            if (lidarNeedsOpen && lidarNewlyOnline) {
                lastLidarReconnectMs = 0;
            }
            const int lidarRetryMs = lidarNeedsOpen
                ? kCameraRediscoverIntervalMs
                : kDeviceReconnectIntervalMs;
            if ((lidarNeedsOpen || lidarOfflineConfirmed) &&
                nowMs - lastLidarReconnectMs >= lidarRetryMs) {
                std::unique_lock<std::mutex> reconfigLock(
                    m_reconfigurationMutex, std::try_to_lock);
                if (reconfigLock.owns_lock() &&
                    !m_reconfiguring.load() &&
                    !m_shutdownRequested.load() &&
                    !m_deviceWatchdogStop.load()) {
                    lastLidarReconnectMs = nowMs;
                    NotifyStatus(
                        lidarNeedsOpen
                            ? std::string("雷达已恢复，正在重新连接")
                            : (DeviceOfflineMessage() +
                               QStringLiteral("，正在尝试重新连接雷达"))
                                  .toUtf8()
                                  .toStdString());
                    lidarReopened = InitRsLidar(true, config.lidarConfig) == 0 &&
                                    IsLidarHandleReady();
                }
            }
        }

        if (cameraReopened || lidarReopened) {
            RecoverFromOfflineDeviceErrorIfReady();
        }
    }
}

void ParkingSpaceGuidePresenter::EnrichDetectionResult(DetectionResult& result) const
{
    const UdpBroadcastConfig config = m_configManager
        ? m_configManager->GetConfigResult().udpBroadcastConfig
        : m_udpBroadcastConfig;

    QString expectedModelType;
    {
        std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
        expectedModelType = m_selectedModelType;
    }

    for (ParkingSpaceGuideInfo& info : result.parkingSpaceInfoList) {
        if (info.targetId.trimmed().isEmpty()) {
            info.targetId = ConfigText(config.targetId, QStringLiteral("T001"));
        }
        if (info.parkId.trimmed().isEmpty()) {
            info.parkId = ConfigText(config.parkId, QStringLiteral("P01"));
        }
        if (info.expectedModelType.trimmed().isEmpty() &&
            !expectedModelType.isEmpty()) {
            info.expectedModelType = expectedModelType;
        }
        if (info.modelType.trimmed().isEmpty()) {
            info.modelType = QStringLiteral("未知");
        }
    }
}

void ParkingSpaceGuidePresenter::UpdateCurrentStatus(const DetectionResult& result)
{
    const UdpBroadcastConfig config = m_configManager
        ? m_configManager->GetConfigResult().udpBroadcastConfig
        : m_udpBroadcastConfig;
    QJsonObject payload = BuildDetectionResultPayload(result, config);
    payload["status"] = BuildStatusJson();
    payload["selfCheck"] = BuildSelfCheckJson();
    const QByteArray data = QJsonDocument(payload)
        .toJson(QJsonDocument::Compact);

    std::lock_guard<std::mutex> lock(m_statusMutex);
    m_currentStatusJson.assign(data.constData(), static_cast<size_t>(data.size()));
}

std::string ParkingSpaceGuidePresenter::CurrentStatusJson() const
{
    std::lock_guard<std::mutex> lock(m_statusMutex);
    if (!m_currentStatusJson.empty()) {
        return m_currentStatusJson;
    }
    const QByteArray data = QJsonDocument(BuildIdleStatusPayload())
        .toJson(QJsonDocument::Compact);
    return std::string(data.constData(), static_cast<size_t>(data.size()));
}

bool ParkingSpaceGuidePresenter::BroadcastDetectionResult(const DetectionResult& result)
{
    Q_UNUSED(result);

    std::lock_guard<std::mutex> lock(m_udpMutex);
    if (!m_udpClient || !m_udpBroadcastConfig.enabled) {
        return false;
    }

    const std::string currentStatus = CurrentStatusJson();
    const QByteArray data(currentStatus.data(), static_cast<int>(currentStatus.size()));
    const int ret = m_udpClient->SendData(m_udpBroadcastConfig.port,
                                          m_udpBroadcastConfig.address.c_str(),
                                          data.constData(),
                                          data.size());
    if (ret != 0) {
        NotifyStatus("组播发送失败：" + std::to_string(ret));
        return false;
    }

    return true;
}

void ParkingSpaceGuidePresenter::NotifyStatus(const std::string& message)
{
    LOG_INFO("%s\n", message.c_str());
    if (StatusCallback()) {
        StatusCallback()->OnStatusUpdate(message);
    }
}

bool ParkingSpaceGuidePresenter::IsCameraRequired() const
{
    if (m_simulationOptions.enabled || !m_configManager) {
        return false;
    }
    return m_configManager->GetConfigResult().mvsCamera.enabled;
}

bool ParkingSpaceGuidePresenter::IsLidarRequired() const
{
    if (m_simulationOptions.enabled || !m_configManager) {
        return false;
    }
    return m_configManager->GetConfigResult().lidarEnabled;
}

bool ParkingSpaceGuidePresenter::HasRequiredDeviceOffline() const
{
    return (IsCameraRequired() && !m_cameraConnected.load()) ||
           (IsLidarRequired() && !m_lidarConnected.load());
}

bool ParkingSpaceGuidePresenter::HasSelfCheckFailed() const
{
    std::lock_guard<std::mutex> recordLock(m_recordMutex);
    return m_hasCompletedSelfCheck && !m_lastSelfCheck.ok;
}

ParkingSpaceGuidePresenter::SelfCheckResult
ParkingSpaceGuidePresenter::LastSelfCheckResult() const
{
    std::lock_guard<std::mutex> recordLock(m_recordMutex);
    return m_lastSelfCheck;
}

bool ParkingSpaceGuidePresenter::ShouldHoldSafetyState() const
{
    return m_emergencyStopLatched.load() ||
           (m_emergencyStopEnabled.load() &&
            (!m_emergencyStopAvailable.load() ||
             m_emergencyStopActive.load())) ||
           (m_initialized.load() &&
            (HasRequiredDeviceOffline() || HasSelfCheckFailed()));
}

QString ParkingSpaceGuidePresenter::DeviceOfflineMessage() const
{
    const bool cameraOffline = IsCameraRequired() && !m_cameraConnected.load();
    const bool lidarOffline = IsLidarRequired() && !m_lidarConnected.load();
    if (cameraOffline && lidarOffline) {
        return QStringLiteral("平面相机和雷达离线");
    }
    if (cameraOffline) {
        return QStringLiteral("平面相机离线");
    }
    if (lidarOffline) {
        return QStringLiteral("雷达离线");
    }
    return QStringLiteral("设备离线");
}

int ParkingSpaceGuidePresenter::DeviceOfflineErrorCode() const
{
    const bool cameraOffline = IsCameraRequired() && !m_cameraConnected.load();
    const bool lidarOffline = IsLidarRequired() && !m_lidarConnected.load();
    if (cameraOffline && lidarOffline) {
        return kDeviceErrorMultiple;
    }
    if (cameraOffline) {
        return kDeviceErrorCamera;
    }
    if (lidarOffline) {
        return kDeviceErrorLidar;
    }
    return kDeviceErrorMultiple;
}

void ParkingSpaceGuidePresenter::ApplySystemErrorForOfflineDevice()
{
    if (m_simulationOptions.enabled ||
        m_shutdownRequested.load() ||
        !m_initialized.load() ||
        m_reconfiguring.load()) {
        return;
    }
    if (m_emergencyStopEnabled.load() &&
        (m_emergencyStopActive.load() ||
         !m_emergencyStopAvailable.load())) {
        return;
    }
    if (!HasRequiredDeviceOffline()) {
        return;
    }

    // 引导中掉线立即停会话，整体状态切到系统错误（ERROR）。
    RequestDetectionStopForSafety();
    m_activated.store(false);
    DetectionResult result = CreateGuideStateResult(
        ParkingGuideState::SystemError,
        QStringLiteral("ERROR"),
        DeviceOfflineMessage(),
        false);
    result.errorCode = DeviceOfflineErrorCode();
    PublishDetectionResult(result, true);
    NotifyWorkStatus(WorkStatus::Error);
    NotifyStatus(DeviceOfflineMessage().toUtf8().toStdString());
    FinishGuideSession(static_cast<int>(ParkingGuideState::SystemError), true);
}

void ParkingSpaceGuidePresenter::RecoverFromOfflineDeviceErrorIfReady()
{
    if (m_simulationOptions.enabled ||
        m_shutdownRequested.load() ||
        !m_initialized.load() ||
        m_reconfiguring.load() ||
        HasRequiredDeviceOffline()) {
        return;
    }
    if (IsCameraRequired() && !IsMvsCameraHandleReady()) {
        return;
    }
    if (IsLidarRequired() && !IsLidarHandleReady()) {
        return;
    }

    // 设备恢复后重新自检，通过才回到 WAIT，否则保持系统错误。
    const SelfCheckResult check = RunSelfCheck();
    {
        std::lock_guard<std::mutex> recordLock(m_recordMutex);
        m_lastSelfCheck = check;
        m_hasCompletedSelfCheck = true;
    }
    if (!check.ok) {
        RejectStartForSelfCheck(check);
        return;
    }
    PublishCurrentSafetyState(true, false);
}

void ParkingSpaceGuidePresenter::NotifyWorkStatus(WorkStatus status)
{
    std::lock_guard<std::mutex> workStatusLock(m_workStatusMutex);
    WorkStatus effectiveStatus = status;
    if (m_emergencyStopEnabled.load() &&
        m_emergencyStopActive.load()) {
        effectiveStatus = WorkStatus::EmergencyStop;
    } else if (m_emergencyStopEnabled.load() &&
               !m_emergencyStopAvailable.load()) {
        effectiveStatus = WorkStatus::Error;
    } else if (m_initialized.load() &&
               (HasRequiredDeviceOffline() || HasSelfCheckFailed())) {
        effectiveStatus = WorkStatus::Error;
    } else if (m_emergencyStopLatched.load()) {
        effectiveStatus = WorkStatus::Ready;
    }

    if (StatusCallback()) {
        StatusCallback()->OnWorkStatusChanged(effectiveStatus);
    }
}

void ParkingSpaceGuidePresenter::NotifyCameraStatus(bool connected, bool publishSafety)
{
    const bool changed = m_cameraConnected.exchange(connected) != connected;
    if (!changed) {
        return;
    }
    if (StatusCallback()) {
        StatusCallback()->OnCamera1StatusChanged(connected);
    }
    PatchAndPublishRuntimeStatus();
    if (!publishSafety) {
        return;
    }
    if (!connected && IsCameraRequired()) {
        ApplySystemErrorForOfflineDevice();
    } else if (connected) {
        RecoverFromOfflineDeviceErrorIfReady();
    }
}

void ParkingSpaceGuidePresenter::NotifyLidarStatus(bool connected, bool publishSafety)
{
    const bool changed = m_lidarConnected.exchange(connected) != connected;
    if (!changed) {
        return;
    }
    if (StatusCallback()) {
        StatusCallback()->OnCamera2StatusChanged(connected);
    }
    PatchAndPublishRuntimeStatus();
    if (!publishSafety) {
        return;
    }
    if (!connected && IsLidarRequired()) {
        ApplySystemErrorForOfflineDevice();
    } else if (connected) {
        RecoverFromOfflineDeviceErrorIfReady();
    }
}

void ParkingSpaceGuidePresenter::NotifyLedStatus(bool connected)
{
    if (StatusCallback()) {
        StatusCallback()->OnSerialConnectionChanged(connected);
    }
}

LedDisplayResult ParkingSpaceGuidePresenter::ConvertLedResult(const DetectionResult& result) const
{
    LedDisplayResult output;
    output.errorCode = result.errorCode;
    if (result.parkingSpaceInfoList.empty()) {
        output.valid = true;
        if (result.errorCode != 0) {
            output.guideCode = 2;
            output.guideStateCode =
                static_cast<int>(ParkingGuideState::SystemError);
            output.stateText = "ERROR";
        } else {
            output.blank = true;
        }
        return output;
    }

    const ParkingSpaceGuideInfo& info = result.parkingSpaceInfoList.front();
    output.valid = true;
    output.guideStateCode = info.guideStateCode;
    output.guideCode = (info.hasException || IsExceptionGuideState(info.guideStateCode)) ? 2 : 1;
    output.stateText = info.guideText.trimmed().toStdString();
    output.modelType = info.modelType.trimmed().toStdString();
    output.distance = static_cast<float>(info.distance);
    output.lateralOffset = static_cast<float>(info.lateralOffset);
    output.angle = static_cast<float>(info.angle);
    output.blank = !IsLedVisibleGuideState(info.guideStateCode);
    return output;
}

bool ParkingSpaceGuidePresenter::CacheMvsFrame(const MvsImageData& image, QImage& frame)
{
    frame = QImage();
    if (!image.pData || image.width == 0 || image.height == 0 || image.dataSize == 0) {
        return false;
    }

    const int width = static_cast<int>(image.width);
    const int height = static_cast<int>(image.height);
    const size_t pixelCount = static_cast<size_t>(width) * static_cast<size_t>(height);
    if (pixelCount == 0) {
        return false;
    }

    QImage rgbImage;
    if (image.pixelFormat == kMvsPixelTypeRGB8 && image.dataSize >= pixelCount * 3) {
        QImage src(image.pData, width, height, width * 3, QImage::Format_RGB888);
        rgbImage = src.copy();
    } else if (image.pixelFormat == kMvsPixelTypeBGR8 && image.dataSize >= pixelCount * 3) {
        QImage src(image.pData, width, height, width * 3, QImage::Format_RGB888);
        rgbImage = src.rgbSwapped();
    } else if (image.pixelFormat == kMvsPixelTypeMono8 && image.dataSize >= pixelCount) {
        QImage src(image.pData, width, height, width, QImage::Format_Grayscale8);
        rgbImage = src.convertToFormat(QImage::Format_RGB888);
    } else {
        return false;
    }

    if (rgbImage.isNull()) {
        return false;
    }

    std::vector<unsigned char> compact(pixelCount * 3);
    for (int row = 0; row < height; ++row) {
        std::memcpy(compact.data() + static_cast<size_t>(row) * static_cast<size_t>(width) * 3,
                    rgbImage.constScanLine(row),
                    static_cast<size_t>(width) * 3);
    }

    CameraFrameInfo frameInfo;
    frameInfo.width = width;
    frameInfo.height = height;
    frameInfo.pixelFormat = image.pixelFormat;
    frameInfo.frameId = image.frameID;
    frameInfo.timestamp = image.timestamp;

    std::lock_guard<std::mutex> lock(m_dataMutex);
    m_latestFrame.swap(compact);
    m_latestFrameInfo = frameInfo;
    m_latestPreviewImage = rgbImage;
    m_hasFrame = true;
    frame = rgbImage;
    return true;
}

int ParkingSpaceGuidePresenter::InitGuideRecordStore()
{
    CloseGuideRecordStore();
    if (!m_configManager) {
        return 0;
    }

    const DatabaseConfig config =
        m_configManager->GetConfigResult().databaseConfig;
    if (!config.enabled) {
        NotifyStatus("引导记录库未启用");
        return 0;
    }

    m_guideRecordStore.reset(new GuideRecordStore());
    if (!m_guideRecordStore->Start(config)) {
        const QString error = m_guideRecordStore->LastError();
        NotifyStatus((error.isEmpty()
            ? QStringLiteral("引导记录库连接失败，引导仍可继续")
            : QStringLiteral("引导记录库连接失败，引导仍可继续：%1").arg(error))
                         .toUtf8()
                         .toStdString());
        m_guideRecordStore.reset();
        return 0;
    }

    NotifyStatus(QStringLiteral("引导记录库已连接：%1:%2/%3")
                     .arg(QString::fromStdString(config.host))
                     .arg(config.port)
                     .arg(QString::fromStdString(config.name))
                     .toUtf8()
                     .toStdString());
    return 0;
}

void ParkingSpaceGuidePresenter::CloseGuideRecordStore()
{
    if (!m_guideRecordStore) {
        return;
    }
    m_guideRecordStore->Stop();
    m_guideRecordStore.reset();
}

ParkingSpaceGuidePresenter::SelfCheckResult
ParkingSpaceGuidePresenter::RunSelfCheck()
{
    SelfCheckResult check;
    if (m_simulationOptions.enabled) {
        check.lidarOk = true;
        check.cameraOk = true;
    } else {
        check.lidarOk = m_lidarDevice && m_lidarDevice->IsRunning();
        check.cameraOk = m_mvsDevice && m_mvsDevice->IsDeviceOpen();
    }

    const QString configPath = PathManager::GetInstance().GetConfigFilePath();
    const QString directory = QFileInfo(configPath).absolutePath();
    QDir().mkpath(directory);
    const QString probePath =
        directory + QStringLiteral("/.psg_write_probe");
    QFile probe(probePath);
    check.storageOk = probe.open(QIODevice::WriteOnly | QIODevice::Truncate) &&
                      probe.write("ok") > 0;
    probe.close();
    probe.remove();

    check.networkOk = false;
    const QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces();
    for (const QNetworkInterface& networkInterface : interfaces) {
        const QNetworkInterface::InterfaceFlags flags = networkInterface.flags();
        if (!flags.testFlag(QNetworkInterface::IsUp) ||
            !flags.testFlag(QNetworkInterface::IsRunning) ||
            flags.testFlag(QNetworkInterface::IsLoopBack)) {
            continue;
        }
        for (const QNetworkAddressEntry& entry :
             networkInterface.addressEntries()) {
            if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol &&
                !entry.ip().isNull() &&
                !entry.ip().isLoopback()) {
                check.networkOk = true;
                break;
            }
        }
        if (check.networkOk) {
            break;
        }
    }

    QStringList failed;
    if (!check.lidarOk) {
        failed << QStringLiteral("雷达");
    }
    if (!check.cameraOk) {
        failed << QStringLiteral("相机");
    }
    if (!check.storageOk) {
        failed << QStringLiteral("存储");
    }
    if (!check.networkOk) {
        failed << QStringLiteral("网络");
    }

    check.ok = failed.isEmpty();
    if (check.ok) {
        check.message = QStringLiteral("自检通过：雷达、相机、存储、网络正常");
        return check;
    }

    const int failCount = failed.size();
    if (failCount > 1) {
        check.errorCode = kDeviceErrorMultiple;
    } else if (!check.lidarOk) {
        check.errorCode = kDeviceErrorLidar;
    } else if (!check.cameraOk) {
        check.errorCode = kDeviceErrorCamera;
    } else if (!check.storageOk) {
        check.errorCode = kDeviceErrorStorage;
    } else {
        check.errorCode = kDeviceErrorNetwork;
    }
    check.message = QStringLiteral("自检失败：%1").arg(failed.join(QStringLiteral("、")));
    return check;
}

bool ParkingSpaceGuidePresenter::RejectStartForSelfCheck(
    const SelfCheckResult& check)
{
    DetectionResult result = CreateGuideStateResult(
        ParkingGuideState::SystemError,
        QStringLiteral("ERROR"),
        check.message,
        false);
    result.errorCode = check.errorCode;
    PublishDetectionResult(result, true);
    NotifyWorkStatus(WorkStatus::Error);
    NotifyStatus(check.message.toUtf8().toStdString());
    return true;
}

void ParkingSpaceGuidePresenter::BeginGuideSession()
{
    if (!CurrentSessionUuid().isEmpty()) {
        FinishGuideSession(static_cast<int>(ParkingGuideState::Waiting), false);
    }

    const QString uuid = QUuid::createUuid().toString(QUuid::WithoutBraces);
    QString expectedModel;
    {
        std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
        m_sessionUuid = uuid;
        m_lastSessionUuid = uuid;
        expectedModel = m_selectedModelType;
    }
    {
        std::lock_guard<std::mutex> recordLock(m_recordMutex);
        m_personChockTimeMs = 0;
        m_chockOnTimeMs = 0;
        m_chockOffTimeMs = 0;
        m_lastSampleWriteMs = 0;
        m_lastSampleStateCode = -1;
    }
    m_activated.store(true);

    if (m_guideRecordStore && m_guideRecordStore->IsReady()) {
        const UdpBroadcastConfig udpConfig = m_configManager
            ? m_configManager->GetConfigResult().udpBroadcastConfig
            : m_udpBroadcastConfig;
        GuideRecordStore::SessionRecord session;
        session.sessionUuid = uuid;
        session.parkId = ConfigText(udpConfig.parkId, QStringLiteral("P01"));
        session.targetId = ConfigText(udpConfig.targetId, QStringLiteral("T001"));
        session.expectedModelType = expectedModel;
        session.startTimeMs = QDateTime::currentMSecsSinceEpoch();
        m_guideRecordStore->BeginSession(session);
    }
    RecordGuideEvent(QStringLiteral("session_begin"),
                     QStringLiteral("引导会话已开始"));
}

void ParkingSpaceGuidePresenter::FinishGuideSession(int finalState,
                                                    bool hasException)
{
    const QString uuid = CurrentSessionUuid();
    if (uuid.isEmpty()) {
        return;
    }

    QString modelType;
    bool modelMatched = false;
    int errorCode = 0;
    QString message;
    qint64 personTime = 0;
    qint64 onTime = 0;
    qint64 offTime = 0;
    {
        std::lock_guard<std::mutex> publishLock(m_publishMutex);
        errorCode = m_lastDetectionResult.errorCode;
        message = m_lastDetectionResult.message;
        if (!m_lastDetectionResult.parkingSpaceInfoList.empty()) {
            const ParkingSpaceGuideInfo& info =
                m_lastDetectionResult.parkingSpaceInfoList.front();
            modelType = info.modelType;
            modelMatched = info.modelMatched;
        }
    }
    {
        std::lock_guard<std::mutex> recordLock(m_recordMutex);
        personTime = m_personChockTimeMs;
        onTime = m_chockOnTimeMs;
        offTime = m_chockOffTimeMs;
    }
    RecordGuideEvent(QStringLiteral("session_end"),
                     QStringLiteral("引导会话已结束"));
    {
        std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
        m_sessionUuid.clear();
        m_lastSessionUuid = uuid;
    }
    m_activated.store(false);

    if (m_guideRecordStore && m_guideRecordStore->IsReady()) {
        m_guideRecordStore->UpdateChockTimes(
            uuid, personTime, onTime, offTime);
        GuideRecordStore::SessionRecord ending;
        ending.sessionUuid = uuid;
        ending.modelType = modelType;
        ending.modelMatched = modelMatched;
        ending.guideStateCode = finalState;
        ending.hasException = hasException;
        ending.errorCode = errorCode;
        ending.message = message;
        m_guideRecordStore->EndSession(ending);
    }
}

void ParkingSpaceGuidePresenter::RecordGuideSample(const DetectionResult& result)
{
    const QString uuid = CurrentSessionUuid();
    if (uuid.isEmpty() ||
        !m_guideRecordStore ||
        !m_guideRecordStore->IsReady()) {
        return;
    }

    const int stateCode = result.parkingSpaceInfoList.empty()
        ? 0
        : result.parkingSpaceInfoList.front().guideStateCode;
    const qint64 now = QDateTime::currentMSecsSinceEpoch();
    int sampleIntervalMs = 200;
    if (m_configManager) {
        sampleIntervalMs = m_configManager->GetConfigResult()
                               .databaseConfig.sampleIntervalMs;
    }

    bool shouldWrite = false;
    {
        std::lock_guard<std::mutex> recordLock(m_recordMutex);
        if (stateCode != m_lastSampleStateCode ||
            now - m_lastSampleWriteMs >= sampleIntervalMs) {
            m_lastSampleStateCode = stateCode;
            m_lastSampleWriteMs = now;
            shouldWrite = true;
        }
    }
    if (!shouldWrite) {
        return;
    }

    const UdpBroadcastConfig config = m_configManager
        ? m_configManager->GetConfigResult().udpBroadcastConfig
        : m_udpBroadcastConfig;
    QJsonObject sample = BuildDetectionResultPayload(result, config);
    sample["status"] = BuildStatusJson();
    sample["selfCheck"] = BuildSelfCheckJson();
    sample["timestamp"] = static_cast<double>(now);
    m_guideRecordStore->WriteSample(uuid, sample);
}

void ParkingSpaceGuidePresenter::RecordGuideEvent(const QString& eventType,
                                                  const QString& message)
{
    if (!m_guideRecordStore || !m_guideRecordStore->IsReady()) {
        return;
    }
    QJsonObject payload;
    if (eventType.contains(QStringLiteral("self_check"))) {
        payload = BuildSelfCheckJson();
    }
    m_guideRecordStore->WriteEvent(
        CurrentSessionUuid(), eventType, message, payload);
}

void ParkingSpaceGuidePresenter::ApplySessionDisplayFields(
    DetectionResult& result) const
{
    qint64 personTime = 0;
    qint64 onTime = 0;
    qint64 offTime = 0;
    {
        std::lock_guard<std::mutex> recordLock(m_recordMutex);
        personTime = m_personChockTimeMs;
        onTime = m_chockOnTimeMs;
        offTime = m_chockOffTimeMs;
    }
    for (ParkingSpaceGuideInfo& info : result.parkingSpaceInfoList) {
        info.personChockTime = personTime;
        info.chockOnTime = onTime;
        info.chockOffTime = offTime;
    }
}

QJsonObject ParkingSpaceGuidePresenter::BuildSelfCheckJson() const
{
    SelfCheckResult check;
    const bool running = m_selfCheckRunning.load();
    {
        std::lock_guard<std::mutex> recordLock(m_recordMutex);
        check = m_lastSelfCheck;
    }
    QJsonObject object;
    object["running"] = running;
    object["ok"] = check.ok;
    object["lidarOk"] = check.lidarOk;
    object["cameraOk"] = check.cameraOk;
    object["storageOk"] = check.storageOk;
    object["networkOk"] = check.networkOk;
    object["errorCode"] = check.errorCode;
    object["message"] = check.message;
    return object;
}

QJsonObject ParkingSpaceGuidePresenter::BuildStatusJson() const
{
    QJsonObject camera;
    camera["name"] = QStringLiteral("平面相机");
    camera["connected"] = m_cameraConnected.load();

    QJsonObject lidar;
    lidar["name"] = QStringLiteral("雷达");
    lidar["connected"] = m_lidarConnected.load();

    QJsonObject emergencyStop;
    emergencyStop["name"] = QStringLiteral("急停");
    emergencyStop["enabled"] = m_emergencyStopEnabled.load();
    emergencyStop["available"] = m_emergencyStopAvailable.load();
    emergencyStop["active"] = m_emergencyStopActive.load();
    emergencyStop["latched"] = m_emergencyStopLatched.load();

    QJsonObject status;
    status["workMode"] = m_maintenanceMode.load()
        ? QStringLiteral("maintenance")
        : QStringLiteral("normal");
    status["activated"] = m_activated.load();
    status["camera"] = camera;
    status["lidar"] = lidar;
    status["emergencyStop"] = emergencyStop;
    return status;
}

QJsonObject ParkingSpaceGuidePresenter::BuildIdleStatusPayload() const
{
    const UdpBroadcastConfig config = m_configManager
        ? m_configManager->GetConfigResult().udpBroadcastConfig
        : m_udpBroadcastConfig;
    DetectionResult idle;
    idle.errorCode = -1;
    idle.message = QStringLiteral("无有效结果");
    QJsonObject payload = BuildDetectionResultPayload(idle, config);
    payload["status"] = BuildStatusJson();
    payload["selfCheck"] = BuildSelfCheckJson();
    return payload;
}

void ParkingSpaceGuidePresenter::PatchAndPublishRuntimeStatus()
{
    // 设备在线状态变化时补发一包，不走完整检测发布路径，避免抢检测锁。
    QJsonObject payload;
    {
        std::lock_guard<std::mutex> lock(m_statusMutex);
        if (!m_currentStatusJson.empty()) {
            const QJsonDocument document = QJsonDocument::fromJson(
                QByteArray(m_currentStatusJson.data(),
                           static_cast<int>(m_currentStatusJson.size())));
            if (document.isObject()) {
                payload = document.object();
            }
        }
    }
    if (payload.isEmpty()) {
        payload = BuildIdleStatusPayload();
    } else {
        payload["status"] = BuildStatusJson();
        payload["timestamp"] = QDateTime::currentMSecsSinceEpoch();
    }

    const QByteArray data = QJsonDocument(payload)
        .toJson(QJsonDocument::Compact);
    {
        std::lock_guard<std::mutex> lock(m_statusMutex);
        m_currentStatusJson.assign(data.constData(),
                                   static_cast<size_t>(data.size()));
    }
    if (m_remoteServer) {
        m_remoteServer->PublishStatus(CurrentStatusJson());
    }
    DetectionResult unused;
    BroadcastDetectionResult(unused);
}

QString ParkingSpaceGuidePresenter::CurrentSessionUuid() const
{
    std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
    return m_sessionUuid;
}

bool ParkingSpaceGuidePresenter::IsSelectableModel(const QString& modelType) const
{
    return CurrentAircraftModels().IsSelectable(modelType);
}

AircraftModelsConfig ParkingSpaceGuidePresenter::CurrentAircraftModels() const
{
    if (!m_configManager) {
        return AircraftModelsConfig::DefaultModels();
    }
    AircraftModelsConfig models =
        m_configManager->GetConfigResult().aircraftModels;
    if (models.models.empty()) {
        models = AircraftModelsConfig::DefaultModels();
    }
    return models;
}

bool ParkingSpaceGuidePresenter::SetMaintenanceMode(bool enabled)
{
    if (m_detectionRunning.load()) {
        NotifyStatus("停机引导运行中，禁止切换工作模式");
        return false;
    }

    const bool changed = m_maintenanceMode.exchange(enabled) != enabled;
    if (changed) {
        RecordGuideEvent(QStringLiteral("maintenance"),
                         enabled
                             ? QStringLiteral("进入维护模式")
                             : QStringLiteral("退出维护模式"));
        NotifyStatus(enabled ? "已进入维护模式" : "已退出维护模式");
    }

    DetectionResult snapshot;
    {
        std::lock_guard<std::mutex> publishLock(m_publishMutex);
        snapshot = m_lastDetectionResult;
    }
    if (snapshot.parkingSpaceInfoList.empty()) {
        snapshot = CreateGuideStateResult(
            ParkingGuideState::Waiting,
            QStringLiteral("WAIT"),
            enabled
                ? QStringLiteral("维护模式")
                : QStringLiteral("等待飞机进入引导区域"),
            false);
    }
    PublishDetectionResult(snapshot);
    return true;
}

bool ParkingSpaceGuidePresenter::IsMaintenanceMode() const
{
    return m_maintenanceMode.load();
}

bool ParkingSpaceGuidePresenter::RecordManualChock(bool chockOn)
{
    const qint64 now = QDateTime::currentMSecsSinceEpoch();
    {
        std::lock_guard<std::mutex> recordLock(m_recordMutex);
        if (chockOn) {
            m_chockOnTimeMs = now;
        } else {
            m_chockOffTimeMs = now;
        }
    }

    QString uuid = CurrentSessionUuid();
    if (uuid.isEmpty()) {
        std::lock_guard<std::mutex> sessionLock(m_sessionMutex);
        uuid = m_lastSessionUuid;
    }

    qint64 personTime = 0;
    qint64 onTime = 0;
    qint64 offTime = 0;
    {
        std::lock_guard<std::mutex> recordLock(m_recordMutex);
        personTime = m_personChockTimeMs;
        onTime = m_chockOnTimeMs;
        offTime = m_chockOffTimeMs;
    }
    if (m_guideRecordStore && m_guideRecordStore->IsReady() && !uuid.isEmpty()) {
        m_guideRecordStore->UpdateChockTimes(
            uuid, personTime, onTime, offTime);
    }
    RecordGuideEvent(chockOn
                         ? QStringLiteral("chock_on")
                         : QStringLiteral("chock_off"),
                     chockOn
                         ? QStringLiteral("人工记录上轮挡时间")
                         : QStringLiteral("人工记录下轮挡时间"));

    DetectionResult snapshot;
    {
        std::lock_guard<std::mutex> publishLock(m_publishMutex);
        snapshot = m_lastDetectionResult;
    }
    if (snapshot.parkingSpaceInfoList.empty()) {
        snapshot = CreateGuideStateResult(
            ParkingGuideState::Waiting,
            QStringLiteral("WAIT"),
            chockOn
                ? QStringLiteral("已记录上轮挡时间")
                : QStringLiteral("已记录下轮挡时间"),
            false);
    } else {
        snapshot.message = chockOn
            ? QStringLiteral("已记录上轮挡时间")
            : QStringLiteral("已记录下轮挡时间");
    }
    PublishDetectionResult(snapshot);
    return true;
}

bool ParkingSpaceGuidePresenter::ValidateControlPassword(
    const QString& password) const
{
    if (!m_configManager) {
        return false;
    }
    const QString expected = QString::fromStdString(
        m_configManager->GetConfigResult().controlPanelConfig.password)
                                 .trimmed();
    if (expected.isEmpty()) {
        return true;
    }
    return password == expected;
}

QJsonObject ParkingSpaceGuidePresenter::ControlPanelConfigJson() const
{
    const AircraftModelsConfig models = CurrentAircraftModels();
    QJsonArray modelArray;
    for (const AircraftModelItem& item : models.models) {
        QJsonObject object;
        object["name"] = item.name;
        object["verifiable"] = models.IsVerifiable(item.name);
        object["stopDistanceCompensation"] = item.stopDistanceCompensation;
        modelArray.append(object);
    }

    QString password;
    bool databaseReady = m_guideRecordStore && m_guideRecordStore->IsReady();
    if (m_configManager) {
        password = QString::fromStdString(
            m_configManager->GetConfigResult().controlPanelConfig.password)
                       .trimmed();
    }

    QJsonObject panel;
    panel["requireLogin"] = !password.isEmpty();
    panel["passwordValidSeconds"] = m_configManager
        ? m_configManager->GetConfigResult().controlPanelConfig.validSeconds
        : 120;
    panel["models"] = modelArray;
    panel["workMode"] = m_maintenanceMode.load()
        ? QStringLiteral("maintenance")
        : QStringLiteral("normal");
    panel["activated"] = m_activated.load();
    panel["databaseReady"] = databaseReady;
    return panel;
}

QJsonArray ParkingSpaceGuidePresenter::ListGuideSessions(int limit)
{
    if (!m_guideRecordStore || !m_guideRecordStore->IsReady()) {
        return QJsonArray();
    }
    return m_guideRecordStore->ListSessions(limit);
}

QJsonArray ParkingSpaceGuidePresenter::ListGuideSamples(const QString& sessionUuid)
{
    if (!m_guideRecordStore ||
        !m_guideRecordStore->IsReady() ||
        sessionUuid.trimmed().isEmpty()) {
        return QJsonArray();
    }
    return m_guideRecordStore->ListSamples(sessionUuid);
}