Vda5050ProtocolService.cs 206 KB

Edit Raw Blame History

using System;
using System.Globalization;
using System.Linq;
using System.Text.Json;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Rcs.Application.Common;
using Rcs.Application.Services;
using Rcs.Application.Services.PathFind;
using Rcs.Application.Services.PathFind.Models;
using Rcs.Application.Services.PathFind.Realtime;
using Rcs.Application.Services.Protocol;
using Rcs.Application.Shared;
using Rcs.Domain.Entities;
using Rcs.Domain.Enums;
using Rcs.Domain.Models.VDA5050;
using Rcs.Domain.Repositories;
using Rcs.Domain.Settings;
using Rcs.Domain.ValueObjects;
using Rcs.Infrastructure.PathFinding.Services;
using StackExchange.Redis;

namespace Rcs.Infrastructure.Services.Protocol;

/// <summary>
/// 通过MQTT与机器人通信
/// @author zzy
/// </summary>
public class Vda5050ProtocolService : IProtocolService
{
    /// <summary>
    /// 正常模式编码。
    /// </summary>
    private const string RouteModeNormal = RouteModeCodes.Normal;

    /// <summary>
    /// 等待模式编码。
    /// </summary>
    private const string RouteModeHold = RouteModeCodes.HoldingAtWaitNode;

    /// <summary>
    /// 排队模式编码。
    /// </summary>
    private const string RouteModeQueue = RouteModeCodes.QueueingForJunction;

    /// <summary>
    /// 占用路口模式编码。
    /// </summary>
    private const string RouteModeOccupying = RouteModeCodes.OccupyingJunction;

    /// <summary>
    /// 绕行模式编码。
    /// </summary>
    private const string RouteModeDetouring = RouteModeCodes.Detouring;

    /// <summary>
    /// 回归模式编码。
    /// </summary>
    private const string RouteModeRejoining = RouteModeCodes.Rejoining;

    /// <summary>
    /// 重规划待执行模式编码。
    /// </summary>
    private const string RouteModeReplanPending = RouteModeCodes.ReplanPending;

    /// <summary>
    /// 阻塞保护模式编码。
    /// </summary>
    private const string RouteModeBlocked = RouteModeCodes.Blocked;

    /// <summary>
    /// 订单首节点允许偏移量（米）。
    /// </summary>
    private const double FirstOrderNodeAllowedDeviationXY = 0.2;

    /// <summary>
    /// 单次下发路径的最小节点数限制（至少包含起点和终点）。
    /// </summary>
    private const int MinDispatchNodeCount = 2;

    private readonly ILogger<Vda5050ProtocolService> _logger;
    private readonly IMqttClientService _mqttClientService;
    private readonly IAgvPathService _agvPathService;
    private readonly IConnectionMultiplexer _redis;
    private readonly IRobotSubTaskRepository _subTaskRepository;
    private readonly IRobotTaskRepository _taskRepository;
    private readonly IRobotRepository _robotRepository;
    private readonly IChargingPileRepository _chargingPileRepository;
    private readonly ITaskTemplateRepository _taskTemplateRepository;
    private readonly INetActionPropertysRepository _netActionPropertysRepository;
    private readonly INetActionExecutionService _netActionExecutionService;
    private readonly IActionConfigurationRepository _actionConfigurationRepository;
    private readonly IRobotCacheService _robotCacheService;

    /// <summary>
    /// 全局导航协调器。
    /// </summary>
    private readonly IGlobalNavigationCoordinator _globalNavigationCoordinator;

    /// <summary>
    /// 等待恢复调度器。
    /// </summary>
    private readonly IGlobalNavigationResumeScheduler _globalNavigationResumeScheduler;

    /// <summary>
    /// 尾段补丁应用器。
    /// </summary>
    private readonly ITailPatchApplier _tailPatchApplier;

    /// <summary>
    /// 应用配置监视器（用于动态刷新CAS参数）。
    /// </summary>
    private readonly IOptionsMonitor<AppSettings> _settingsMonitor;
    private readonly AppSettings _settings;

    /// <summary>
    /// 路径CAS运行配置快照。
    /// </summary>
    private GlobalPathCasSettings _pathCasSettings = new();

    /// <summary>
    /// CAS直接提交尝试次数。
    /// </summary>
    private long _pathCasDirectAttemptCount;

    /// <summary>
    /// CAS直接提交成功次数。
    /// </summary>
    private long _pathCasDirectSuccessCount;

    /// <summary>
    /// CAS直接提交冲突次数。
    /// </summary>
    private long _pathCasConflictCount;

    /// <summary>
    /// CAS回退提交尝试次数。
    /// </summary>
    private long _pathCasFallbackAttemptCount;

    /// <summary>
    /// CAS回退提交成功次数。
    /// </summary>
    private long _pathCasFallbackSuccessCount;

    /// <summary>
    /// CAS最终失败次数。
    /// </summary>
    private long _pathCasFailureCount;

    /// <summary>
    /// 上次输出CAS指标日志时间。
    /// </summary>
    private DateTime _lastPathCasMetricsLogUtc = DateTime.Now;

    /// <summary>
    /// CAS指标日志输出间隔。
    /// </summary>
    private TimeSpan _pathCasMetricsInterval;

    /// <summary>
    /// CAS窗口统计锁。
    /// </summary>
    private readonly object _pathCasWindowLock = new();

    /// <summary>
    /// CAS统计窗口起始时间。
    /// </summary>
    private DateTime _pathCasWindowStartedUtc = DateTime.Now;

    /// <summary>
    /// 当前窗口CAS尝试次数。
    /// </summary>
    private long _pathCasWindowAttemptCount;

    /// <summary>
    /// 当前窗口CAS冲突次数。
    /// </summary>
    private long _pathCasWindowConflictCount;

    /// <summary>
    /// 当前窗口CAS失败次数。
    /// </summary>
    private long _pathCasWindowFailureCount;

    /// <summary>
    /// CAS统计窗口时长。
    /// </summary>
    private TimeSpan _pathCasWindowDuration;

    /// <summary>
    /// 需要进行切割的资源类型集合
    /// 排除: markedArea, waitingArea, other
    /// </summary>
    private static readonly HashSet<int> CuttingResourceTypes = new()
    {
        (int)MapResourcesTYPE.dock,
        (int)MapResourcesTYPE.charger,
        (int)MapResourcesTYPE.elevator,
        (int)MapResourcesTYPE.airlock,
        (int)MapResourcesTYPE.conveyor,
        (int)MapResourcesTYPE.storage
    };

    /// <summary>
    /// 初始化 VDA5050 协议服务。
    /// </summary>
    public Vda5050ProtocolService(
        ILogger<Vda5050ProtocolService> logger,
        IMqttClientService mqttClientService,
        IAgvPathService agvPathService,
        IConnectionMultiplexer redis,
        IRobotSubTaskRepository subTaskRepository,
        IRobotTaskRepository taskRepository,
        IRobotRepository robotRepository,
        IChargingPileRepository chargingPileRepository,
        IOptionsMonitor<AppSettings> settings,
        ITaskTemplateRepository taskTemplateRepository,
        INetActionPropertysRepository netActionPropertysRepository,
        INetActionExecutionService netActionExecutionService,
        IActionConfigurationRepository actionConfigurationRepository,
        IRobotCacheService robotCacheService,
        IGlobalNavigationCoordinator globalNavigationCoordinator,
        IGlobalNavigationResumeScheduler globalNavigationResumeScheduler,
        ITailPatchApplier tailPatchApplier)
    {
        _logger = logger;
        _mqttClientService = mqttClientService;
        _agvPathService = agvPathService;
        _redis = redis;
        _subTaskRepository = subTaskRepository;
        _taskRepository = taskRepository;
        _robotRepository = robotRepository;
        _chargingPileRepository = chargingPileRepository;
        _settingsMonitor = settings;
        _settings = settings.CurrentValue;
        ApplyPathCasSettings(_settings);
        _taskTemplateRepository = taskTemplateRepository;
        _netActionPropertysRepository = netActionPropertysRepository;
        _netActionExecutionService = netActionExecutionService;
        _actionConfigurationRepository = actionConfigurationRepository;
        _robotCacheService = robotCacheService;
        _globalNavigationCoordinator = globalNavigationCoordinator;
        _globalNavigationResumeScheduler = globalNavigationResumeScheduler;
        _tailPatchApplier = tailPatchApplier;
    }

    /// <summary>
    ///
    /// </summary>
    public ProtocolType ProtocolType => ProtocolType.VDA;

    /// <summary>
    /// 根据任务执行上下文做校验并准备发送订单参数。
    /// </summary>
    public async Task<ApiResponse> PrepareSendOrderAsync(Robot robot, RobotTask task, CancellationToken ct = default)
    {
        _logger.LogInformation("VDA5050 - 发送Order，机器人: {SerialNumber}, 订单: {OrderId}",
            robot.RobotSerialNumber, task.TaskCode);

        if (!robot.CurrentNodeId.HasValue)
        {
            return ApiResponse.Failed("VDA5050 - 机器人当前节点为空，无法规划路径");
        }

        var currentSubTask = task.GetNextExecutableSubTask();
        if (currentSubTask == null)
        {
            return ApiResponse.Failed("不存在待执行的子任务");
        }

        var mapId = task.BeginLocation?.MapNode?.MapId
                    ?? currentSubTask.BeginNode?.MapId
                    ?? currentSubTask.EndNode?.MapId
                    ?? robot.CurrentMapCodeId;

        if (!mapId.HasValue)
        {
            return ApiResponse.Failed("VDA5050 - 起点地图未找到，无法规划路径");
        }

        if (currentSubTask.EndNodeId == Guid.Empty)
        {
            return ApiResponse.Failed("VDA5050 - 终点节点为空，无法规划路径");
        }

        _logger.LogInformation("VDA5050 - 找到子任务: {SubTaskId}, 执行次数: {ExecutionCount}",
            currentSubTask.SubTaskId, currentSubTask.ExecutionCount);

        return await SendOrderWithTaskContextAsync(
            robot,
            priority: task.Priority,
            endNodeId: currentSubTask.EndNodeId,
            containerId: task.ContainerID,
            taskId: task.TaskId,
            subTaskId: currentSubTask.SubTaskId,
            taskTemplateId: task.TaskTemplateId,
            subTaskSequence: currentSubTask.Sequence,
            taskCode: task.TaskCode,
            mapId: mapId.Value,
            ct: ct);
    }

    /// <summary>
    /// 直接发送VDA5050订单（无任务上下文）。
    /// </summary>
    public async Task<ApiResponse> SendOrderAsync(
        Robot robot,
        int priority,
        Guid endNodeId,
        string? containerId,
        CancellationToken ct = default)
    {
        return await SendOrderWithTaskContextAsync(
            robot,
            priority,
            endNodeId,
            containerId,
            taskId: null,
            subTaskId: null,
            taskTemplateId: null,
            subTaskSequence: null,
            taskCode: null,
            mapId: robot.CurrentMapCodeId,
            ct: ct);
    }

    /// <summary>
    /// 基于任务上下文发送VDA5050订单（支持仅传递上下文ID，ID可为空）。
    /// </summary>
    public async Task<ApiResponse> SendOrderWithTaskContextAsync(
        Robot robot,
        int priority,
        Guid endNodeId,
        string? containerId,
        Guid? taskId = null,
        Guid? subTaskId = null,
        Guid? taskTemplateId = null,
        int? subTaskSequence = null,
        string? taskCode = null,
        Guid? mapId = null,
        CancellationToken ct = default)
    {
        if (!robot.CurrentNodeId.HasValue)
        {
            return ApiResponse.Failed("VDA5050 - 机器人当前节点为空，无法规划路径");
        }

        if (endNodeId == Guid.Empty)
        {
            return ApiResponse.Failed("VDA5050 - 终点节点为空，无法规划路径");
        }

        var resolvedMapId = mapId ?? robot.CurrentMapCodeId;
        if (!resolvedMapId.HasValue)
        {
            return ApiResponse.Failed("VDA5050 - 机器人当前地图为空，无法规划路径");
        }

        var graph = await _agvPathService.GetOrBuildGraphAsync(resolvedMapId.Value);
        if (graph == null)
        {
            return ApiResponse.Failed("VDA5050 - 地图图结构加载失败");
        }

        if (!graph.Nodes.TryGetValue(endNodeId, out var endNode))
        {
            return ApiResponse.Failed("VDA5050 - 终点节点不在当前地图中，无法规划路径");
        }

        PathRequest request = new PathRequest
        {
            RobotId = robot.RobotId,
            MapId = resolvedMapId.Value,
            StartNodeId = robot.CurrentNodeId.Value,
            EndNodeId = endNodeId,
            CurrentTheta = robot.CurrentTheta ?? 0,
            IsLoaded = !string.IsNullOrWhiteSpace(containerId),
            Priority = priority,
            BatteryLevel = robot.BatteryLevel ?? 100,
            MovementType = robot.MovementType,
            ForkRadOffsets = robot.ForkRadOffset,
            RequiredEndRad = endNode.Theta
        };

        var pathResult = await _agvPathService.CalculatePathAsync(request, ct);
        if (!pathResult.Success)
        {
            return ApiResponse.Failed($"VDA5050 - 路径规划失败: {pathResult.ErrorMessage}");
        }

        var segmentsWithCode = _agvPathService.EnrichSegmentsWithCode(pathResult.Segments, graph);
        if (segmentsWithCode.Count == 0)
        {
            return ApiResponse.Failed("VDA5050 - 路径为空，无法发送订单");
        }

        var resolvedTaskId = taskId.HasValue && taskId.Value != Guid.Empty
            ? taskId.Value
            : Guid.NewGuid();
        var resolvedSubTaskId = subTaskId.HasValue && subTaskId.Value != Guid.Empty
            ? subTaskId.Value
            : Guid.NewGuid();
        var resolvedSubTaskSequence = subTaskSequence.GetValueOrDefault(1);
        if (resolvedSubTaskSequence <= 0)
        {
            resolvedSubTaskSequence = 1;
        }

        var resolvedTaskCode = string.IsNullOrWhiteSpace(taskCode)
            ? resolvedSubTaskId.ToString()
            : taskCode.Trim();

        var dispatchSubTask = CreateDispatchSubTask(
            robot,
            resolvedTaskId,
            resolvedSubTaskId,
            endNodeId,
            resolvedSubTaskSequence);

        // 获取任务模板步骤（用于动作装载）
        var taskStep = await GetTaskStepForSubTaskAsync(taskTemplateId, resolvedSubTaskSequence, ct);
        var terminalActionContext = await ResolveTerminalLocationActionContextAsync(
            resolvedSubTaskId,
            resolvedSubTaskSequence,
            ct);

        var segmentedPath = SplitSegmentsByBoundary(segmentsWithCode, graph, robot, terminalActionContext);
        if (segmentedPath.Count == 0)
        {
            return ApiResponse.Failed("VDA5050 - 路径分段失败");
        }

        // 检查并补充虚拟原地路径（用于支持 Apply 类型前置动作）
        if (!EnsureVirtualSegmentForApplyActions(segmentedPath, request, graph, terminalActionContext))
        {
            // 具体失败原因会在 EnsureVirtualSegmentForApplyActions 内记录告警日志。
            return ApiResponse.Failed("VDA5050 - 补充虚拟路径失败");
        }

        // 将任务模板动作装载到对应的路径段（包括网络动作和资源网络动作）
        if (!await LoadActionsToSegmentsAsync(
                segmentedPath,
                taskStep,
                graph,
                robot,
                addStopChargingActionAtStart: robot.Charging,
                terminalActionContext: terminalActionContext))
        {
            return ApiResponse.Failed("VDA5050 - 动作装载失败");
        }

        if (!await SaveSegmentedPathAsync(
                robot,
                resolvedTaskId,
                resolvedTaskCode,
                resolvedSubTaskId,
                resolvedMapId.Value,
                graph.MapCode,
                segmentedPath,
                graph,
                ct))
        {
            return ApiResponse.Failed("VDA5050 - 路径缓存保存失败");
        }

        return await SendNextSegmentAsync(robot, dispatchSubTask, ct);

    }

    /// <summary>
    /// 基于上下文ID构建一次下发所需的临时子任务对象（可用于未落库场景）。
    /// </summary>
    private static RobotSubTask CreateDispatchSubTask(
        Robot robot,
        Guid taskId,
        Guid subTaskId,
        Guid endNodeId,
        int sequence)
    {
        return new RobotSubTask
        {
            SubTaskId = subTaskId,
            TaskId = taskId,
            RobotId = robot.RobotId,
            BeginNodeId = robot.CurrentNodeId ?? Guid.Empty,
            EndNodeId = endNodeId,
            Sequence = sequence,
            Status = Rcs.Domain.Entities.TaskStatus.Pending,
            ExecutionCount = 0,
            CreatedAt = DateTime.Now,
            UpdatedAt = DateTime.Now
        };
    }

    /// <summary>
    /// 取消指定订单（通过发送cancelOrder即时动作）
    /// </summary>
    public async Task CancelOrderAsync(Robot robot, string? orderId, CancellationToken ct = default)
    {
        _logger.LogInformation("VDA5050 - 取消订单，机器人: {SerialNumber}, 订单: {OrderId}",
            robot.RobotSerialNumber, orderId);

        var instantAction = CreateInstantAction(robot, "cancelOrder");
        await SendInstantActionAsync(robot, instantAction, ct);

        // 删除Redis中该任务的VDA路径缓存数据
        if (!string.IsNullOrEmpty(orderId))
        {
            await ClearVdaPathCacheAsync(robot.RobotId, orderId);
        }
    }

    /// <summary>
    /// 取消机器人所有任务
    /// @author zzy
    /// </summary>
    public async Task CancelRobotTasksAsync(Robot robot, CancellationToken ct = default)
    {
        _logger.LogInformation("VDA5050 - 取消所有任务，机器人 {SerialNumber}", robot.RobotSerialNumber);

        var instantAction = CreateInstantAction(robot, "cancelOrder");
        await SendInstantActionAsync(robot, instantAction, ct);

        // 删除Redis中该机器人所有任务的VDA路径缓存数据
        await ClearAllVdaPathCacheAsync(robot.RobotId);
        // 清理缓存中的Path路径数据
        await _robotCacheService.SetLocationValueAsync(
            robot.RobotManufacturer, robot.RobotSerialNumber, "Path", "");
        // 释放该机器人的所有路径锁
        await _agvPathService.ReleaseAllLocksAsync(robot.RobotId);

        await Task.Delay(TimeSpan.FromSeconds(2), ct); // 等待2秒，确保机器人收到取消指令并处理

    }

    /// <summary>
    /// 发送即时动作指令，发送后递增持久化 HeaderId
    /// @author zzy
    /// 2026-02-11 更新：发送后持久化 HeaderId
    /// </summary>
    public async Task SendInstantActionAsync(Robot robot, InstantAction actions, CancellationToken ct = default)
    {
        await _mqttClientService.PublishInstantActionsAsync(
            robot.ProtocolName,
            robot.ProtocolVersion,
            robot.RobotManufacturer,
            robot.RobotSerialNumber,
            actions,
            ct: ct);

        // 持久化递增后的 HeaderId
        await _robotRepository.UpdateAsync(robot, ct);
        await _robotRepository.SaveChangesAsync(ct);
    }

    /// <summary>
    /// 复位机器人（通过发送stateRequest即时动作   /// </summary>
    public async Task ResetRobotAsync(Robot robot, CancellationToken ct = default)
    {
        _logger.LogInformation("VDA5050 - 复位机器人 {SerialNumber}", robot.RobotSerialNumber);

        var instantAction = CreateInstantAction(robot, "stateRequest");
        await SendInstantActionAsync(robot, instantAction, ct);
    }

    /// <summary>
    ///
    /// </summary>
    public Task ConfirmExceptionAsync(Robot robot, CancellationToken ct = default)
    {
        _logger.LogInformation("VDA5050 - 不存在确认工况动作 {SerialNumber}", robot.RobotSerialNumber);
        return Task.CompletedTask;
    }

    public async Task<ApiResponse> StartChargingAsync(Robot robot, string actionName, CancellationToken ct = default)
    {
        var finalActionName = string.IsNullOrWhiteSpace(actionName) ? "startCharging" : actionName.Trim();
        _logger.LogInformation(
            "VDA5050 - 发送开始充电即时动作。机器人={SerialNumber}, 动作={ActionName}",
            robot.RobotSerialNumber,
            finalActionName);

        var instantAction = CreateInstantAction(robot, finalActionName);
        await SendInstantActionAsync(robot, instantAction, ct);
        return ApiResponse.Successful();
    }

    public async Task<ApiResponse> StopChargingAsync(Robot robot, CancellationToken ct = default)
    {
        const string stopChargingActionName = "stopCharging";
        _logger.LogInformation(
            "VDA5050 - 发送停止充电即时动作。机器人={SerialNumber}, 动作={ActionName}",
            robot.RobotSerialNumber,
            stopChargingActionName);

        var instantAction = CreateInstantAction(robot, stopChargingActionName);
        await SendInstantActionAsync(robot, instantAction, ct);

        var chargingPile = await _chargingPileRepository.FirstOrDefaultAsync(
            p => p.CurrentChargingRobotId.HasValue && p.CurrentChargingRobotId.Value == robot.RobotId,
            ct);

        if (chargingPile == null)
        {
            _logger.LogDebug(
                "VDA5050 - 停止充电后未找到已绑定的充电桩。机器人={RobotCode}",
                robot.RobotCode);
            return ApiResponse.Successful();
        }

        chargingPile.CurrentChargingRobotId = null;
        chargingPile.UpdatedAt = DateTime.Now;

        await _chargingPileRepository.UpdateAsync(chargingPile, ct);
        await _chargingPileRepository.SaveChangesAsync(ct);

        _logger.LogInformation(
            "VDA5050 - 停止充电成功后已解绑充电桩。机器人={RobotCode}, 充电桩={PileCode}",
            robot.RobotCode,
            chargingPile.PileCode);

        return ApiResponse.Successful();
    }

    /// <summary>
    /// 构建VDA5050订单基础结构（Header/基础字段/空节点与边列表）。
    /// 每次构建时递增 robot.HeaderId
    /// @author zzy
    /// 2026-02-11 更新：递增 HeaderId
    /// </summary>
    private Domain.Models.VDA5050.Order BuildVdaOrder(Robot robot, RobotSubTask subTask)
    {
        var orderUpdateId = subTask?.ExecutionCount ?? 0;
        robot.HeaderId++;

        return new Domain.Models.VDA5050.Order
        {
            HeaderId = (int)robot.HeaderId,
            Timestamp = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fffzzz"),
            Version = robot.ProtocolVersion,
            Manufacturer = robot.RobotManufacturer,
            SerialNumber = robot.RobotSerialNumber,
            ZoneSetId = robot.CurrentMapCodeId.ToString(),
            OrderId = subTask.SubTaskId.ToString(),
            OrderUpdateId = orderUpdateId,
            Nodes = new List<Node>(),
            Edges = new List<Edge>()
        };
    }
    /// <summary>
    /// 将路径段转换为VDA5050的Nodes与Edges并填充到订单中。
    /// @author zzy
    /// 2026-02-09 更新：改为异步方法，查询数据库获取动作参数
    /// 2026-02-25 更新：增加 startSequenceId 参数，支持分段发送时延续已发送的 sequenceId
    /// </summary>
    /// <param name="order">待填充的VDA5050订单</param>
    /// <param name="segments">路径段列表</param>
    /// <param name="graph">地图图结构</param>
    /// <param name="robot">机器人实体</param>
    /// <param name="subTask">子任务实体</param>
    /// <param name="startSequenceId">起始 sequenceId，后续段需延续上一次发送的值</param>
    /// <param name="ct">取消令牌</param>
    /// <param name="temporaryNextSegment">临时追加的下一段首条路径（仅用于Released=false预告）</param>
    /// <returns>本次填充后的最大 sequenceId</returns>
    private async Task<int> FillOrderWithSegmentsAsync(
        Domain.Models.VDA5050.Order order,
        List<PathSegmentWithCode> segments,
        PathGraph graph,
        Robot robot,
        RobotSubTask subTask,
        int startSequenceId = 0,
        CancellationToken ct = default,
        PathSegmentWithCode? temporaryNextSegment = null)
    {
        if (segments.Count == 0) return startSequenceId;

        // 使用图结构中的节点数据进行节点位置填充。
        var nodeLookup = graph.Nodes;
        var mapCode = !string.IsNullOrWhiteSpace(graph.MapCode)
            ? graph.MapCode
            : graph.MapId.ToString();

        // 构建上下文对象，用于参数解析
        var context = new ParameterResolveContext
        {
            Robot = robot,
            SubTask = subTask
        };

        var sequenceId = startSequenceId;
        var firstSeg = segments[0];

        // 构建第一个节点，填充第一个segment的StartNodeActions
        var firstNode = BuildNode(firstSeg.FromNodeId, firstSeg.FromNodeCode, nodeLookup, mapCode, sequenceId, robot.CoordinateScale, firstSeg.StartTheta);
        if (firstNode.NodePosition != null && order.OrderUpdateId == 0)
        {
            firstNode.NodePosition.AllowedDeviationXY = FirstOrderNodeAllowedDeviationXY;
        }

        if (firstSeg.StartNodeActions.Count > 0)
        {
            firstNode.Actions = await ConvertStepActionsToVdaActionsAsync(firstSeg.StartNodeActions, context, ct);
        }
        order.Nodes.Add(firstNode);

        foreach (var seg in segments)
        {
            var edgeSequenceId = sequenceId + 1;
            var nodeSequenceId = sequenceId + 2;

            var startNodeCode = seg.FromNodeCode;
            string? edgeCodeOverride = null;

            if (string.Equals(seg.FromNodeCode, seg.ToNodeCode, StringComparison.Ordinal))
            {
                startNodeCode = AppendTempSuffix(seg.FromNodeCode);
                edgeCodeOverride = string.IsNullOrEmpty(seg.EdgeCode)
                    ? string.Concat(startNodeCode, seg.ToNodeCode)
                    : seg.EdgeCode;

                if (order.Nodes.Count > 0 && string.Equals(order.Nodes[^1].NodeId, seg.FromNodeCode, StringComparison.Ordinal))
                {
                    order.Nodes[^1].NodeId = startNodeCode;
                }
            }

            graph.Edges.TryGetValue(seg.EdgeId, out var graphEdge);
            var edge = BuildEdge(
                seg,
                edgeSequenceId,
                graphEdge,
                robot.CoordinateScale,
                startNodeCode,
                edgeCodeOverride);
            var node = BuildNode(seg.ToNodeId, seg.ToNodeCode, nodeLookup, mapCode, nodeSequenceId, robot.CoordinateScale, seg.EndTheta);

            if (seg.EndNodeActions.Count > 0)
            {
                node.Actions = await ConvertStepActionsToVdaActionsAsync(seg.EndNodeActions, context, ct);
            }
            order.Edges.Add(edge);
            order.Nodes.Add(node);
            sequenceId = nodeSequenceId;
        }

        // 临时预告下一个节点路径：仅追加一条边和终点节点，Released=false，不影响已发送序列号延续。
        if (temporaryNextSegment != null)
        {
            var tempEdgeSequenceId = sequenceId + 1;
            var tempNodeSequenceId = sequenceId + 2;

            graph.Edges.TryGetValue(temporaryNextSegment.EdgeId, out var tempGraphEdge);
            var tempEdge = BuildEdge(
                temporaryNextSegment,
                tempEdgeSequenceId,
                tempGraphEdge,
                robot.CoordinateScale);
            var tempNode = BuildNode(
                temporaryNextSegment.ToNodeId,
                temporaryNextSegment.ToNodeCode,
                nodeLookup,
                mapCode,
                tempNodeSequenceId,
                robot.CoordinateScale,
                temporaryNextSegment.EndTheta);

            tempEdge.Released = false;
            tempNode.Released = false;

            order.Edges.Add(tempEdge);
            order.Nodes.Add(tempNode);
        }

        return sequenceId;
    }

    /// <summary>
    /// 为编码追加临时后缀，避免与正式编码冲突。
    /// </summary>
    private static string AppendTempSuffix(string code)
    {
        if (string.IsNullOrEmpty(code))
        {
            return code;
        }

        return code.EndsWith("-temp", StringComparison.Ordinal)
            ? code
            : string.Concat(code, "-temp");
    }

    /// <summary>
    /// 参数解析上下文
    /// @author zzy
    /// 2026-02-09 创建
    /// </summary>
    private class ParameterResolveContext
    {
        public Robot Robot { get; set; } = null!;
        public RobotSubTask SubTask { get; set; } = null!;
        public VdaSegmentedPathCache? PathCache { get; set; }
    }

    /// <summary>
    /// 将 StepAction 列表转换为 VDA5050 Action 列表
    /// @author zzy
    /// 2026-02-09 更新：查询数据库获取参数，使用 Action 构造函数
    /// 2026-02-09 更新：支持 ParameterSourceType 通过反射解析参数值
    /// </summary>
    private async Task<List<Domain.Models.VDA5050.Action>> ConvertStepActionsToVdaActionsAsync(
        List<StepAction> stepActions,
        ParameterResolveContext context,
        CancellationToken ct = default)
    {
        var actions = new List<Domain.Models.VDA5050.Action>();

        foreach (var stepAction in stepActions.OrderBy(a => a.Order))
        {
            if (!stepAction.ActionConfigId.HasValue)
            {
                continue;
            }
            // 查询 ActionConfiguration 获取参数定义
            var config = await _actionConfigurationRepository.GetFullByIdAsync(stepAction.ActionConfigId.Value);
            if (config == null)
            {
                _logger.LogWarning("未找到动作配置，ActionConfigId: {ActionConfigId}", stepAction.ActionConfigId);
                continue;
            }
            // 构建参数列表
            var parameters = new List<(string Key, object Value)>();
            if (config?.Parameters != null)
            {
                foreach (var paramDef in config.Parameters.OrderBy(p => p.SortOrder))
                {
                    // 根据 ParameterSourceType 解析参数值
                    object paramValue = await ResolveParameterValueAsync(paramDef, context, ct);
                    paramValue = ApplyValueConstraint(paramValue, paramDef);
                    parameters.Add((paramDef.ParameterName, paramValue));
                }
            }

            // 使用构造函数创建 Action，传入参数
            var vdaAction = new Domain.Models.VDA5050.Action(
                actionType: config.ActionName ?? string.Empty,
                par: parameters,
                actionId: stepAction.ActionId.ToString(),
                blockingType: stepAction.BlockingType.ToString().ToUpper(),
                description: stepAction.Description ?? config.ActionName ?? string.Empty
            );

            // 设置描述
            vdaAction.ActionDescription = stepAction.Description ?? stepAction.ActionName ?? string.Empty;

            actions.Add(vdaAction);
        }

        return actions;
    }

    /// <summary>
    /// 解析参数值为对应类型
    /// @author zzy
    /// 2026-02-09 创建
    /// </summary>
    private static object ParseParameterValue(string? defaultValue, ParameterValueType valueType)
    {
        if (string.IsNullOrEmpty(defaultValue))
        {
            return valueType switch
            {
                ParameterValueType.Int => 0,
                ParameterValueType.Float => 0.0,
                ParameterValueType.Bool => false,
                _ => string.Empty
            };
        }

        try
        {
            return valueType switch
            {
                ParameterValueType.Int => int.Parse(defaultValue),
                ParameterValueType.Float => double.Parse(defaultValue),
                ParameterValueType.Bool => bool.Parse(defaultValue),
                _ => defaultValue
            };
        }
        catch
        {
            return valueType switch
            {
                ParameterValueType.Int => 0,
                ParameterValueType.Float => 0.0,
                ParameterValueType.Bool => false,
                _ => defaultValue
            };
        }
    }

    /// <summary>
    /// 根据 ParameterSourceType 解析参数值
    /// - 如果 ParameterSourceType 为 null，使用默认值
    /// - 如果不为 null，通过反射从对应对象获取值
    /// @author zzy
    /// 2026-02-09 创建
    /// 2026-03-03 更新：添加 PathCache 支持，从 Redis 路径缓存获取参数
    /// </summary>
    private async Task<object> ResolveParameterValueAsync(
        Domain.Entities.ActionParameterDefinition paramDef,
        ParameterResolveContext context,
        CancellationToken ct)
    {
        // 如果 ParameterSourceType 为 null，使用默认值
        if (paramDef.ParameterSourceType == null)
        {
            return ParseParameterValue(paramDef.DefaultValue, paramDef.ParameterValueType);
        }

        // 根据 ParameterSourceType 获取源对象
        object? sourceObject = paramDef.ParameterSourceType switch
        {
            ParameterSourceType.SubTask => context.SubTask,
            ParameterSourceType.Robot => context.Robot,
            ParameterSourceType.PathCache => await GetPathCacheAsync(context.Robot.RobotId, context.SubTask.TaskId, context.SubTask.SubTaskId),
            _ => null
        };

        // 如果源对象不存在，使用默认值
        if (sourceObject == null || string.IsNullOrEmpty(paramDef.ParameterSourcePath))
        {
            return ParseParameterValue(paramDef.DefaultValue, paramDef.ParameterValueType);
        }

        try
        {
            // 通过反射获取属性值（应用 FieldPathConfigurationService 的递归规则）
            var value = GetPropertyValueByPath(sourceObject, paramDef.ParameterSourcePath, 0, null);

            // 如果值为 null，使用默认值
            if (value == null)
            {
                return ParseParameterValue(paramDef.DefaultValue, paramDef.ParameterValueType);
            }

            // 转换为目标类型
            return ConvertToParameterValueType(value, paramDef.ParameterValueType);
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "解析参数值失败: {ParameterName}, SourceType: {SourceType}, Path: {SourcePath}",
                paramDef.ParameterName, paramDef.ParameterSourceType, paramDef.ParameterSourcePath);
            return ParseParameterValue(paramDef.DefaultValue, paramDef.ParameterValueType);
        }
    }

    private object ApplyValueConstraint(object resolvedValue, Domain.Entities.ActionParameterDefinition paramDef)
    {
        if (string.IsNullOrWhiteSpace(paramDef.ValueConstraints))
        {
            return ConvertToParameterValueType(resolvedValue, paramDef.ParameterValueType);
        }

        var constraintValue = paramDef.ValueConstraints.Trim();

        try
        {
            return paramDef.ParameterValueType switch
            {
                ParameterValueType.String => (resolvedValue?.ToString() ?? string.Empty) + constraintValue,
                ParameterValueType.Int => Convert.ToInt32(ConvertToParameterValueType(resolvedValue, ParameterValueType.Int)) +
                                          ParseConstraintInt(constraintValue),
                ParameterValueType.Float => Convert.ToDouble(ConvertToParameterValueType(resolvedValue, ParameterValueType.Float), CultureInfo.InvariantCulture) +
                                            ParseConstraintDouble(constraintValue),
                _ => ConvertToParameterValueType(resolvedValue, paramDef.ParameterValueType)
            };
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex,
                "参数约束值运算失败: {ParameterName}, ValueType: {ValueType}, Constraint: {Constraint}",
                paramDef.ParameterName, paramDef.ParameterValueType, paramDef.ValueConstraints);
            return ConvertToParameterValueType(resolvedValue, paramDef.ParameterValueType);
        }
    }

    private static int ParseConstraintInt(string constraintValue)
    {
        try
        {
            if (int.TryParse(constraintValue, NumberStyles.Integer, CultureInfo.InvariantCulture, out var value) ||
            int.TryParse(constraintValue, NumberStyles.Integer, CultureInfo.CurrentCulture, out value))
            {
                return value;
            }
            return 0;
        }
        catch
        {

            return 0;
        }
    }

    private static double ParseConstraintDouble(string constraintValue)
    {
    try
        {
            if (double.TryParse(constraintValue, NumberStyles.Float | NumberStyles.AllowThousands,
                CultureInfo.InvariantCulture, out var value) ||
            double.TryParse(constraintValue, NumberStyles.Float | NumberStyles.AllowThousands,
                CultureInfo.CurrentCulture, out value))
            {
                return value;
            }
            return 0.0;
        }
        catch
        {
            return 0.0;
        }
    }

    /// <summary>
    /// 从 Redis 获取路径缓存
    /// @author zzy
    /// 2026-03-03 创建
    /// </summary>
    private async Task<VdaSegmentedPathCache?> GetPathCacheAsync(Guid robotId, Guid taskId, Guid subTaskId)
    {
        var key = $"{_settings.Redis.KeyPrefixes.VdaPath}:{robotId}:{taskId}:{subTaskId}";
        var cacheData = await _redis.GetDatabase().StringGetAsync(key);

        if (!cacheData.HasValue) return null;

        try
        {
            return JsonSerializer.Deserialize<VdaSegmentedPathCache>(cacheData.ToString());
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "路径缓存反序列化失败: RobotId={RobotId}, TaskId={TaskId}, SubTaskId={SubTaskId}",
                robotId, taskId, subTaskId);
            return null;
        }
    }

    // 最大递归深度，防止循环引用（与 FieldPathConfigurationService 保持一致）
    private const int MaxParameterResolveDepth = 5;

    // 排除的属性列表（与 FieldPathConfigurationService 保持一致）
    private static readonly HashSet<string> ExcludedParameterProperties = new(StringComparer.OrdinalIgnoreCase)
    {
        "DomainEvents", "NodeStates", "EdgeStates"
    };

    // 支持的嵌套导航属性（与 FieldPathConfigurationService 保持一致）
    private static readonly Dictionary<string, Type> SupportedParameterNavigationProperties = new(StringComparer.OrdinalIgnoreCase)
    {
        // Robot 相关
        { "Map", typeof(Domain.Entities.Map) },
        { "MapNode", typeof(MapNode) },
        // SubTask 相关
        { "Robot", typeof(Robot) },
        { "BeginLocation", typeof(StorageLocation) },
        { "EndLocation", typeof(StorageLocation) },
        { "TaskTemplate", typeof(TaskTemplate) },
        // Node 相关
        { "StorageLocationType", typeof(StorageLocationType) },
        // Edge 相关
        { "StartNode", typeof(MapNode) },
        { "EndNode", typeof(MapNode) }
    };

    /// <summary>
    /// 通过属性路径获取对象值（支持嵌套属性，如 "LoadType" 或 "EndLocation.LocationCode"）
    /// 按照 FieldPathConfigurationService 的规则进行递归查询：
    /// - 最大递归深度限制
    /// - 排除特定属性
    /// - 只展开支持的导航属性
    /// @author zzy
    /// 2026-02-09 创建
    /// 2026-02-09 更新：应用 FieldPathConfigurationService 的递归规则
    /// </summary>
    private static object? GetPropertyValueByPath(object obj, string propertyPath, int currentDepth = 0, HashSet<Type>? visitedTypes = null)
    {
        if (currentDepth > MaxParameterResolveDepth)
        {
            return null;
        }

        visitedTypes ??= new HashSet<Type>();
        var currentObj = obj;
        var properties = propertyPath.Split('.');

        foreach (var propName in properties)
        {
            if (currentObj == null)
            {
                return null;
            }

            // 检查是否达到最大深度
            if (currentDepth >= MaxParameterResolveDepth)
            {
                return null;
            }

            // 处理集合索引，如 "Items[0]"
            var propNameClean = propName;
            int? index = null;
            if (propName.Contains('[') && propName.EndsWith(']'))
            {
                var startIdx = propName.IndexOf('[');
                var endIdx = propName.IndexOf(']');
                if (startIdx > 0 && endIdx > startIdx)
                {
                    propNameClean = propName.Substring(0, startIdx);
                    if (int.TryParse(propName.Substring(startIdx + 1, endIdx - startIdx - 1), out var idx))
                    {
                        index = idx;
                    }
                }
            }

            // 检查是否为排除的属性
            if (ExcludedParameterProperties.Contains(propNameClean))
            {
                return null;
            }

            // 获取属性值
            var prop = currentObj.GetType().GetProperty(propNameClean, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
            if (prop == null)
            {
                return null;
            }

            // 检查是否为支持的导航属性或普通属性
            var propType = prop.PropertyType;
            var underlyingType = Nullable.GetUnderlyingType(propType) ?? propType;

            // 如果是导航属性，检查是否在支持列表中
            if (IsParameterNavigationProperty(prop, out var navType))
            {
                // 检查类型是否已访问过（防止循环引用）
                if (navType != null && visitedTypes.Contains(navType))
                {
                    return null;
                }

                // 标记为已访问
                if (navType != null)
                {
                    visitedTypes.Add(navType);
                }
            }
            // 如果是集合类型，跳过（不支持的集合类型）
            else if (IsParameterCollectionType(propType))
            {
                return null;
            }

            currentObj = prop.GetValue(currentObj);

            // 如果存在索引，获取集合元素
            if (index.HasValue && currentObj != null)
            {
                if (currentObj is System.Collections.IList list && index.Value < list.Count)
                {
                    currentObj = list[index.Value];
                }
                else
                {
                    return null;
                }
            }

            currentDepth++;
        }

        return currentObj;
    }

    /// <summary>
    /// 检查属性是否为导航属性（与 FieldPathConfigurationService 规则一致）
    /// @author zzy
    /// 2026-02-09 创建
    /// </summary>
    private static bool IsParameterNavigationProperty(System.Reflection.PropertyInfo property, out Type? navigationType)
    {
        navigationType = null;

        // 检查是否在支持的导航属性列表中
        if (SupportedParameterNavigationProperties.TryGetValue(property.Name, out var supportedType))
        {
            navigationType = supportedType;
            return true;
        }

        // 检查是否有 ForeignKey 特性
        var foreignKeyAttr = System.Reflection.CustomAttributeExtensions.GetCustomAttribute<System.ComponentModel.DataAnnotations.Schema.ForeignKeyAttribute>(property, false);
        if (foreignKeyAttr != null)
        {
            navigationType = property.PropertyType;
            return true;
        }

        // 检查是否为虚拟导航属性（EF Core 导航属性通常标记为 virtual）
        if (property.GetMethod?.IsVirtual == true)
        {
            // 确保不是集合类型
            if (!IsParameterCollectionType(property.PropertyType))
            {
                navigationType = property.PropertyType;
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// 检查是否为集合类型（与 FieldPathConfigurationService 规则一致）
    /// @author zzy
    /// 2026-02-09 创建
    /// </summary>
    private static bool IsParameterCollectionType(Type type)
    {
        if (type == typeof(string))
            return false;

        return typeof(System.Collections.IEnumerable).IsAssignableFrom(type)
               && type.IsGenericType
               && type.GetGenericTypeDefinition() != typeof(Nullable<>);
    }

    /// <summary>
    /// 将值转换为 ParameterValueType 对应的类型
    /// @author zzy
    /// 2026-02-09 创建
    /// </summary>
    private static object ConvertToParameterValueType(object value, ParameterValueType targetType)
    {
        try
        {
            return targetType switch
            {
                ParameterValueType.Int => Convert.ToInt32(value),
                ParameterValueType.Float => Convert.ToDouble(value),
                ParameterValueType.Bool => Convert.ToBoolean(value),
                ParameterValueType.String => value.ToString() ?? string.Empty,
                _ => value.ToString() ?? string.Empty
            };
        }
        catch
        {
            return targetType switch
            {
                ParameterValueType.Int => 0,
                ParameterValueType.Float => 0.0,
                ParameterValueType.Bool => false,
                _ => string.Empty
            };
        }
    }

    /// <summary>
    /// 根据节点缓存构建VDA5050节点信息。
    /// 使用图结构的节点数据。
    /// </summary>
    private static Node BuildNode(Guid nodeId, string nodeCode, IReadOnlyDictionary<Guid, PathNode> lookup, string mapCode, int sequenceId, double coordinateScale, double theta)
    {
        var node = new Node
        {
            NodeId = string.IsNullOrEmpty(nodeCode) ? nodeId.ToString() : nodeCode,
            SequenceId = sequenceId,
            Released = true
        };

        if (lookup.TryGetValue(nodeId, out var pathNode))
        {
            node.NodePosition = new NodePosition
            {
                X = pathNode.X / coordinateScale,
                Y = pathNode.Y / coordinateScale,
                Theta = theta,
                MapId = mapCode,
                AllowedDeviationXY = pathNode.MaxCoordinateOffset ?? (PositionConstants.AllowedDeviationPosition / coordinateScale)
            };
        }

        return node;
    }

    /// <summary>
    /// 根据路径段构建VDA5050边信息。
    /// </summary>
    private static Edge BuildEdge(
        PathSegmentWithCode seg,
        int sequenceId,
        PathEdge? graphEdge = null,
        double coordinateScale = 1,
        string? startNodeCodeOverride = null,
        string? edgeCodeOverride = null)
    {
        var edgeCode = edgeCodeOverride ?? (string.IsNullOrEmpty(seg.EdgeCode) ? seg.EdgeId.ToString() : seg.EdgeCode);

        var edge = new Edge()
        {
            EdgeId = edgeCode,
            SequenceId = sequenceId,
            Released = true,
            StartNodeId = startNodeCodeOverride ?? seg.FromNodeCode,
            EndNodeId = seg.ToNodeCode,
            MaxSpeed = seg.MaxSpeed,
            Orientation = seg.Angle
        };

        if (graphEdge?.CurveType == MapEdgeCurveType.Nurbs)
        {
            var trajectory = BuildNurbsTrajectory(graphEdge, coordinateScale);
            if (trajectory != null)
            {
                edge.Trajectory = trajectory;
            }
        }

        return edge;
    }

    /// <summary>
    /// 从路径边几何信息构建 VDA5050 NURBS 轨迹。
    /// </summary>
    private static Trajectory? BuildNurbsTrajectory(PathEdge edge, double coordinateScale)
    {
        var controlPoints = edge.ControlPoints;
        if (controlPoints == null || controlPoints.Count < 2)
        {
            return null;
        }

        var normalizedScale = Math.Abs(coordinateScale) < double.Epsilon ? 1 : coordinateScale;
        var weights = edge.Weights;
        var vdaControlPoints = new List<ControlPoint>(controlPoints.Count);
        for (var i = 0; i < controlPoints.Count; i++)
        {
            var cp = controlPoints[i];
            var weight = weights != null && i < weights.Count ? weights[i] : 1d;
            vdaControlPoints.Add(new ControlPoint
            {
                X = cp.X / normalizedScale,
                Y = cp.Y / normalizedScale,
                Weight = weight
            });
        }

        var n = controlPoints.Count - 1;
        var degree = Math.Clamp(edge.Degree ?? Math.Min(3, n), 1, n);
        var knotVector = edge.Knots != null && edge.Knots.Count > 0
            ? edge.Knots.ToList()
            : BuildOpenUniformKnotVector(controlPoints.Count, degree);

        return new Trajectory
        {
            Degree = degree,
            KnotVector = knotVector,
            ControlPoints = vdaControlPoints
        };
    }

    /// <summary>
    /// 构建开区间均匀节点向量（open-uniform knot vector）。
    /// </summary>
    private static List<double> BuildOpenUniformKnotVector(int controlPointCount, int degree)
    {
        var n = controlPointCount - 1;
        var knotCount = n + degree + 2;
        var knots = new List<double>(knotCount);
        for (var i = 0; i < knotCount; i++)
        {
            if (i <= degree)
            {
                knots.Add(0d);
                continue;
            }

            if (i >= knotCount - degree - 1)
            {
                knots.Add(1d);
                continue;
            }

            var denominator = n - degree + 1;
            knots.Add(denominator <= 0 ? 0d : (double)(i - degree) / denominator);
        }

        return knots;
    }

    /// <summary>
    /// 缓存分段后的路径，供后续分段下发或恢复使用。
    /// @author zzy
    /// 2026-02-05 更新：支持两层切割结构
    /// </summary>
    private async Task<bool> SaveSegmentedPathAsync(
        Robot robot,
        Guid taskId,
        string taskCode,
        Guid subTaskId,
        Guid mapId,
        string? mapCode,
        List<List<List<PathSegmentWithCode>>> segmentedPath,
        PathGraph graph,
        CancellationToken ct)
    {
        try
        {
            var junctionSegments = segmentedPath
                .Select(junctionGroup => new VdaJunctionSegmentCache
                {
                    ResourceSegments = junctionGroup.Select(resourceGroup => new VdaSegmentCacheItem
                    {
                        Segments = resourceGroup
                    }).ToList()
                })
                .ToList();

            var cache = new VdaSegmentedPathCache
            {
                TaskId = taskId,
                TaskCode = string.IsNullOrWhiteSpace(taskCode) ? subTaskId.ToString() : taskCode,
                RobotId = robot.RobotId,
                MapId = mapId,
                MapCode = mapCode ?? string.Empty,
                CreatedAt = DateTime.Now,
                CurrentJunctionIndex = 0,
                CurrentResourceIndex = 0,
                JunctionSegments = junctionSegments,
                PlanVersion = 1,
                RouteMode = "Normal",
                OriginalGoalNodeCode = segmentedPath.LastOrDefault()?
                    .LastOrDefault()?
                    .LastOrDefault()?
                    .ToNodeCode
            };

            // 提取最后一个路径段的货叉夹角信息并填充到姿态信息中
            // @author zzy
            // 2026-03-03 新增：从路径终点提取货叉与车头的夹角
            var lastJunction = segmentedPath.LastOrDefault();
            var lastResource = lastJunction?.LastOrDefault();
            var lastSegment = lastResource?.LastOrDefault();
            if (lastSegment?.ForkAngleOffset.HasValue == true)
            {
                cache.PoseInfo = new VdaPoseInfo
                {
                    EndForkAngleOffset = lastSegment.ForkAngleOffset.Value
                };
            }

            var key = $"{_settings.Redis.KeyPrefixes.VdaPath}:{robot.RobotId}:{taskId}:{subTaskId}";
            var payload = JsonSerializer.Serialize(cache);
            var db = _redis.GetDatabase();
            var tx = db.CreateTransaction();
            _ = tx.StringSetAsync(key, payload);
            _ = tx.StringSetAsync(BuildPathPlanVersionKey(key), cache.PlanVersion.ToString());
            var result = await tx.ExecuteAsync();
            if (!result)
            {
                _logger.LogError("VDA5050 - 路径缓存写入Redis失败，机器人: {RobotId}, 任务: {TaskId}", robot.RobotId, taskId);
                return false;
            }

            // 异步写入机器人路径坐标到位置缓存（不等待，fire-and-forget）
            // @author zzy
            _ = SavePathToRobotLocationAsync(robot, segmentedPath, graph);

            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "VDA5050 - 保存路径缓存异常，机器人: {RobotId}, 任务: {TaskId}", robot.RobotId, taskId);
            return false;
        }
    }

    /// <summary>
    /// 从分段路径中提取所有节点坐标，写入机器人位置缓存的Path字段
    /// 格式: List&lt;List&lt;double&gt;&gt;，外层为点位集合，内层为每个点的 [x, y]
    /// @author zzy
    /// </summary>
    /// <param name="robot">机器人实体</param>
    /// <param name="segmentedPath">分段路径（三层嵌套结构）</param>
    /// <param name="graph">路径图结构（包含节点坐标信息）</param>
    private async Task SavePathToRobotLocationAsync(
        Robot robot,
        List<List<List<PathSegmentWithCode>>> segmentedPath,
        PathGraph graph)
    {
        try
        {
            // 按顺序收集所有路径节点ID（去重保持顺序）
            var orderedNodeIds = new List<Guid>();
            foreach (var junctionGroup in segmentedPath)
            {
                foreach (var resourceGroup in junctionGroup)
                {
                    foreach (var segment in resourceGroup)
                    {
                        // 添加起始节点（避免重复添加与上一段终点相同的节点）
                        if (orderedNodeIds.Count == 0 || orderedNodeIds[^1] != segment.FromNodeId)
                        {
                            orderedNodeIds.Add(segment.FromNodeId);
                        }
                        // 添加终止节点
                        orderedNodeIds.Add(segment.ToNodeId);
                    }
                }
            }

            // 将节点ID转换为 [x, y] 坐标列表
            var path = new List<List<double>>();
            foreach (var nodeId in orderedNodeIds)
            {
                if (graph.Nodes.TryGetValue(nodeId, out var node))
                {
                    path.Add(new List<double> { node.X, node.Y });
                }
            }

            if (path.Count > 0)
            {
                var pathJson = JsonSerializer.Serialize(path);
                await _robotCacheService.SetLocationValueAsync(
                    robot.RobotManufacturer, robot.RobotSerialNumber, "Path", pathJson);
            }
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "VDA5050 - 写入机器人路径坐标到位置缓存失败，机器人: {RobotId}", robot.RobotId);
        }
    }


    /// <summary>
    /// 按两层结构切割路径：
    /// 第一层：路口切割（用于节点锁/路径锁管理）
    /// 第二层：资源边界切割
    /// </summary>
    /// <remarks>
    /// 返回结构：List&lt;List&lt;List&lt;PathSegmentWithCode&gt;&gt;&gt;
    /// - 外层：路口切割后的段落（一级列表）
    /// - 中层：资源边界切割后的子段落（二级列表）
    /// - 内层：路径片段列表
    ///
    /// 注意：资源边界切割节点基于**整个原始路径**预计算，
    /// 而不是每个切割后的子段局部判断。
    ///
    /// 资源边界切割特殊规则：
    /// - 当资源边界切割点落在路口节点时，切割位置前移到路口前一个非路口节点
    /// - 预计算由 GetResourceBoundaryCutNodes 完成
    ///
    /// @author zzy
    /// 2026-02-05 重构为两层切割架构
    /// 2026-03-28 更新：移除模板切割，仅保留资源边界切割
    /// 2026-02-26 更新：资源边界切割改为基于完整路径预计算，路口前移
    /// </remarks>
    private List<List<List<PathSegmentWithCode>>> SplitSegmentsByBoundary(
        List<PathSegmentWithCode> segments,
        PathGraph graph,
        Robot robot,
        TerminalLocationActionContext? terminalActionContext)
    {
        var result = new List<List<List<PathSegmentWithCode>>>();
        if (segments.Count == 0) return result;

        // 获取路口节点集合（用于路口吸收规则）
        var junctionNodes = GetJunctionNodes(graph);

        // 基于原始完整路径预计算资源边界切割节点（路口前移）
        var resourceBoundaryCutNodes = GetResourceBoundaryCutNodes(segments, graph, junctionNodes);

        // 第一层：路口切割
        var junctionSegments = SplitByJunctions(segments, graph, robot);

        // 第二层：对每个路口段进行资源边界切割
        foreach (var junctionGroup in junctionSegments)
        {
            var resourceSegments = SplitByResourceBoundary(junctionGroup, resourceBoundaryCutNodes);
            result.Add(resourceSegments);
        }

        // 终点库位存在申请/完成事件时，确保真实终点段独立，便于后续虚拟段追加与动作挂载。
        if (terminalActionContext is { HasAnyAction: true })
        {
            EnsureTerminalSegmentIsolated(result);
        }

        var maxDispatchNodeCount = GetMaxDispatchNodeCount();
        return EnforceMaxDispatchNodeCount(result, maxDispatchNodeCount);
    }

    /// <summary>
    /// 获取单次下发路径允许的最大节点数。
    /// </summary>
    private int GetMaxDispatchNodeCount()
    {
        var configuredCount = _settingsMonitor.CurrentValue.Vda5050.MaxDispatchNodeCount;
        return Math.Max(MinDispatchNodeCount, configuredCount);
    }

    /// <summary>
    /// 将每个资源段按最大节点数强制切割，确保单次下发不会超过上限。
    /// </summary>
    private static List<List<List<PathSegmentWithCode>>> EnforceMaxDispatchNodeCount(
        List<List<List<PathSegmentWithCode>>> segmentedPath,
        int maxDispatchNodeCount)
    {
        if (segmentedPath.Count == 0)
        {
            return segmentedPath;
        }

        var maxSegmentsPerDispatch = Math.Max(1, maxDispatchNodeCount - 1);
        var normalized = new List<List<List<PathSegmentWithCode>>>(segmentedPath.Count);

        foreach (var junctionGroup in segmentedPath)
        {
            var normalizedResourceGroups = new List<List<PathSegmentWithCode>>();
            foreach (var resourceGroup in junctionGroup)
            {
                if (resourceGroup.Count <= maxSegmentsPerDispatch)
                {
                    normalizedResourceGroups.Add(resourceGroup);
                    continue;
                }

                for (var i = 0; i < resourceGroup.Count; i += maxSegmentsPerDispatch)
                {
                    normalizedResourceGroups.Add(resourceGroup.Skip(i).Take(maxSegmentsPerDispatch).ToList());
                }
            }

            if (normalizedResourceGroups.Count > 0)
            {
                normalized.Add(normalizedResourceGroups);
            }
        }

        return normalized;
    }

    /// <summary>
    /// 当终点库位存在申请/完成事件时，确保真实终点段独立成组，便于后续追加终点虚拟段并精确挂载动作。
    /// </summary>
    private static void EnsureTerminalSegmentIsolated(List<List<List<PathSegmentWithCode>>> segmentedPath)
    {
        if (segmentedPath.Count == 0) return;
        var lastJunctionGroup = segmentedPath[^1];
        if (lastJunctionGroup.Count == 0) return;

        var lastResourceGroup = lastJunctionGroup[^1];
        if (lastResourceGroup.Count <= 1) return;

        var terminalSegment = lastResourceGroup[^1];
        lastResourceGroup.RemoveAt(lastResourceGroup.Count - 1);
        lastJunctionGroup.Add(new List<PathSegmentWithCode> { terminalSegment });
    }
    /// <summary>
    /// 第一层切割：按路口节点切割（用于节点锁/路径锁管理）
    /// </summary>
    /// <remarks>
    /// 路口节点：在图中相邻节点数 >= 3 的节点。
    /// 分段规则：
    ///   1. 根据机器人尺寸（长宽）和转弯半径计算路口旋转范围
    ///   2. 在该旋转范围外沿路径向前的第一个点进行切割
    ///   3. 连续路口：在第一个路口处切割，后续连续路口不切割
    ///   4. 如果路口前没有可切割点（路径起点紧接路口或旋转范围覆盖起点），在路口边后切割（兜底）
    ///      例如：L00(路口)→N17 不切割；L00→中心路口→N17 分段为 [L00→中心路口], [中心路口→N17]
    /// 示例：P→A→B(路口)→C→D(路口)→E(路口)→F 分段为 [P→A], [A→B→C], [C→D→E→F]
    /// @author zzy
    /// 2026-02-26 修复：首个路口切割位置统一为路口前一个节点，与非首个路口一致
    /// 2026-03-05 优化：按机器人旋转范围向前回溯切割点
    /// </remarks>
    private static List<List<PathSegmentWithCode>> SplitByJunctions(
        List<PathSegmentWithCode> segments,
        PathGraph graph,
        Robot robot)
    {
        var result = new List<List<PathSegmentWithCode>>();
        if (segments.Count == 0) return result;

        var junctionNodes = GetJunctionNodes(graph);
        bool IsJunction(Guid nodeId) => junctionNodes.Contains(nodeId);
        var rotationRange = CalculateJunctionRotationRange(robot);

        // 收集切割点索引（在哪些边之后进行切割）
        var cutIndices = new List<int>();

        for (var i = 0; i < segments.Count; i++)
        {
            var seg = segments[i];
            var isToJunction = IsJunction(seg.ToNodeId);

            if (isToJunction && !IsJunction(seg.FromNodeId))
            {
                var cutIndex = GetJunctionCutIndexByRotationRange(segments, graph, i, rotationRange);
                if (cutIndex.HasValue)
                {
                    cutIndices.Add(cutIndex.Value);
                }
                else if (i == 0 && i < segments.Count - 1)
                {
                    // 路径起点紧接路口时，兜底在路口边后切割
                    cutIndices.Add(i);
                }
            }
        }

        // 根据切割点分割路径
        var startIndex = 0;
        foreach (var cutIndex in cutIndices)
        {
            if (cutIndex >= startIndex && cutIndex < segments.Count)
            {
                var segmentLength = cutIndex - startIndex + 1;
                if (segmentLength > 0)
                {
                    result.Add(segments.Skip(startIndex).Take(segmentLength).ToList());
                }
                startIndex = cutIndex + 1;
            }
        }

        // 添加最后一段
        if (startIndex < segments.Count)
        {
            result.Add(segments.Skip(startIndex).ToList());
        }

        // 如果没有切割点，整段作为一个子段
        if (result.Count == 0)
        {
            result.Add(segments.ToList());
        }

        return result;
    }

    /// <summary>
    /// 计算路口旋转范围（米）。
    /// 旋转范围 = 转弯半径 + 车体外接圆半径（长宽对角线的一半）
    /// </summary>
    private static double CalculateJunctionRotationRange(Robot robot)
    {
        // var robotLength = Math.Max(robot.Length ?? 0d, 0d);
        // var robotWidth = Math.Max(robot.Width ?? 0d, 0d);
        var turningRadius = Math.Max(robot.Radius ?? 0d, 0d);

        //var bodyOuterRadius = Math.Sqrt((robotLength * robotLength) + (robotWidth * robotWidth)) / 2d;
        return turningRadius ;
    }

    /// <summary>
    /// 在路口前沿路径向前回溯，找到旋转范围外的第一个可切割点对应的边索引。
    /// 返回值表示“在哪条边后切割”；null 表示没有可用切割点。
    /// </summary>
    private static int? GetJunctionCutIndexByRotationRange(
        IReadOnlyList<PathSegmentWithCode> segments,
        PathGraph graph,
        int junctionEdgeIndex,
        double rotationRange)
    {
        if (junctionEdgeIndex <= 0)
        {
            return null;
        }

        if (rotationRange <= 0)
        {
            return junctionEdgeIndex - 1;
        }

        var accumulatedDistance = 0d;
        var totalBackDistance = 0d;
        for (var i = junctionEdgeIndex; i >= 0; i--)
        {
            var segmentLength = GetSegmentLengthForJunctionSplit(segments[i], graph);
            accumulatedDistance += segmentLength;
            totalBackDistance += segmentLength;

            // 当前 FromNode 到路口的路径距离已在旋转范围外，
            // 对应切割点是该 FromNode，等价于在前一条边后切割。
            if (accumulatedDistance > rotationRange)
            {
                if (i > 0)
                {
                    return i - 1;
                }

                // 路径起点就是范围外第一个点，无法在起点前切割。
                return null;
            }
        }

        // 地图边长缺失（全部为0）时，回退到原有策略：路口前一条边切割。
        if (totalBackDistance <= 0d)
        {
            return junctionEdgeIndex - 1;
        }

        return null;
    }

    /// <summary>
    /// 获取用于路口切割的段长（米）。
    /// 直接使用节点坐标欧氏距离。
    /// </summary>
    private static double GetSegmentLengthForJunctionSplit(PathSegmentWithCode segment, PathGraph graph)
    {
        if (graph.Nodes.TryGetValue(segment.FromNodeId, out var fromNode) &&
            graph.Nodes.TryGetValue(segment.ToNodeId, out var toNode))
        {
            var dx = toNode.X - fromNode.X;
            var dy = toNode.Y - fromNode.Y;
            var distance = Math.Sqrt((dx * dx) + (dy * dy));
            return Math.Max(distance, 0d);
        }

        return 0d;
    }

    /// <summary>
    /// 第二层切割：按资源边界切割
    /// </summary>
    /// <remarks>
    /// 切割规则：
    /// - ActionType.Apply（申请）：需要实际切割
    /// - ActionType.Notify（通知）：不需要切割，仅挂载动作
    ///
    /// 资源边界切割节点：由调用者基于完整路径预计算，路口前移已在预计算阶段处理
    ///
    /// @author zzy
    /// 2026-03-28 更新：移除模板切割
    /// 2026-02-26 重构：资源边界切割改为预计算模式，路口前移逻辑移至 GetResourceBoundaryCutNodes
    /// </remarks>
    private static List<List<PathSegmentWithCode>> SplitByResourceBoundary(
        List<PathSegmentWithCode> segments,
        HashSet<Guid> resourceBoundaryCutNodes)
    {
        var result = new List<List<PathSegmentWithCode>>();
        if (segments.Count == 0) return result;

        // 收集切割点索引
        var cutIndices = new List<int>();

        for (var i = 0; i < segments.Count; i++)
        {
            var seg = segments[i];
            var isResBoundaryCut = resourceBoundaryCutNodes.Contains(seg.ToNodeId);

            // 资源边界切割（路口前移已在预计算阶段处理）
            if (isResBoundaryCut)
            {
                cutIndices.Add(i);
            }
        }

        // 根据切割点分割路径
        var startIndex = 0;
        foreach (var cutIndex in cutIndices)
        {
            if (cutIndex >= startIndex && cutIndex < segments.Count)
            {
                var segmentLength = cutIndex - startIndex + 1;
                if (segmentLength > 0)
                {
                    result.Add(segments.Skip(startIndex).Take(segmentLength).ToList());
                }
                startIndex = cutIndex + 1;
            }
        }

        // 添加最后一段
        if (startIndex < segments.Count)
        {
            result.Add(segments.Skip(startIndex).ToList());
        }

        // 如果没有切割点，整段作为一个子段
        if (result.Count == 0)
        {
            result.Add(segments.ToList());
        }

        return result;
    }

    /// <summary>
    /// 基于完整路径预计算资源边界切割节点
    /// </summary>
    /// <remarks>
    /// 遍历完整路径检测资源编码变化（进入/离开资源区域），根据资源的动作类型决定是否切割及切割位置：
    ///
    /// 进入资源（ToNode 在资源内，FromNode 不在）：
    /// - Pre1(Apply)  → 切割点 = 进入前一个点（seg.FromNodeId）
    /// - Post1(Apply) → 切割点 = 进入后第一个点（seg.ToNodeId）
    ///
    /// 离开资源（FromNode 在资源内，ToNode 不在）：
    /// - Pre2(Apply)  → 切割点 = 离开前一个点（seg.FromNodeId）
    /// - Post2(Apply) → 切割点 = 离开后第一个点（seg.ToNodeId）
    ///
    /// 非 Apply 类型（None/Notify/Charge）的动作不产生切割点。
    /// 当切割点落在路口节点时，沿路径向前搜索第一个非路口节点作为替代切割点。
    ///
    /// @author zzy
    /// 2026-02-26 创建
    /// 2026-02-26 更新：根据资源动作类型（Apply）决定切割点位置
    /// </remarks>
    private static HashSet<Guid> GetResourceBoundaryCutNodes(
        List<PathSegmentWithCode> segments,
        PathGraph graph,
        HashSet<Guid> junctionNodes)
    {
        var cutNodes = new HashSet<Guid>();
        if (segments.Count == 0) return cutNodes;

        var resourceLookup = BuildNodeResourceLookup(graph);

        // 建立资源编码到资源实体的映射（仅切割类型）
        var resourceByCode = graph.Resources
            .Where(r => CuttingResourceTypes.Contains(r.Type))
            .ToDictionary(r => r.ResourceCode, StringComparer.OrdinalIgnoreCase);

        // 将切割点加入集合，路口节点时向前搜索非路口节点
        void AddCutNode(Guid nodeId, int segIndex)
        {
            if (junctionNodes.Contains(nodeId))
            {
                // 沿路径向前找第一个非路口节点
                for (var j = segIndex; j >= 0; j--)
                {
                    var candidateId = segments[j].FromNodeId;
                    if (!junctionNodes.Contains(candidateId))
                    {
                        cutNodes.Add(candidateId);
                        return;
                    }
                }
                // 全是路口节点（极端情况），放弃该切割点
            }
            else
            {
                cutNodes.Add(nodeId);
            }
        }

        for (var i = 0; i < segments.Count; i++)
        {
            var seg = segments[i];
            var fromRes = resourceLookup.TryGetValue(seg.FromNodeId, out var fr) ? fr : new HashSet<string>();
            var toRes = resourceLookup.TryGetValue(seg.ToNodeId, out var tr) ? tr : new HashSet<string>();

            // 检测进入资源（ToNode 在资源内，FromNode 不在）
            var enteringResources = toRes.Except(fromRes);
            foreach (var resCode in enteringResources)
            {
                if (!resourceByCode.TryGetValue(resCode, out var resource)) continue;

                // Pre1(Apply) → 进入前一个点
                if ((resource.PreAction1Type ?? ActionType.None) == ActionType.Apply)
                {
                    AddCutNode(seg.FromNodeId, i > 0 ? i - 1 : i);
                }

                // Post1(Apply) → 进入后第一个点
                if ((resource.PostAction1Type ?? ActionType.None) == ActionType.Apply)
                {
                    AddCutNode(seg.ToNodeId, i);
                }
            }

            // 检测离开资源（FromNode 在资源内，ToNode 不在）
            var leavingResources = fromRes.Except(toRes);
            foreach (var resCode in leavingResources)
            {
                if (!resourceByCode.TryGetValue(resCode, out var resource)) continue;

                // Pre2(Apply) → 离开前一个点
                if ((resource.PreAction2Type ?? ActionType.None) == ActionType.Apply)
                {
                    AddCutNode(seg.FromNodeId, i > 0 ? i - 1 : i);
                }

                // Post2(Apply) → 离开后第一个点
                if ((resource.PostAction2Type ?? ActionType.None) == ActionType.Apply)
                {
                    AddCutNode(seg.ToNodeId, i);
                }
            }
        }

        return cutNodes;
    }

    /// <summary>
    /// 根据子任务序号获取对应的任务模板步骤
    /// @author zzy
    /// </summary>
    private async Task<TaskStep?> GetTaskStepForSubTaskAsync(
        Guid? templateId,
        int sequence,
        CancellationToken ct)
    {
        if (!templateId.HasValue) return null;
        var template = await _taskTemplateRepository.GetWithFullDetailsAsync(templateId.Value, ct);
        return template?.TaskSteps?.OrderBy(s => s.Order).ElementAtOrDefault(sequence - 1);
    }

    /// <summary>
    /// 解析“子任务终点节点库位类型”对应的申请/完成事件上下文。
    /// 规则：
    /// - sequence=1（取货） -> PickupApplyRequestConfigId / PickupCompleteRequestConfigId
    /// - sequence=2（放货） -> DropApplyRequestConfigId / DropCompleteRequestConfigId
    /// - 其他 sequence 不处理
    /// </summary>
    private async Task<TerminalLocationActionContext?> ResolveTerminalLocationActionContextAsync(
        Guid subTaskId,
        int resolvedSubTaskSequence,
        CancellationToken ct)
    {
        if (subTaskId == Guid.Empty || (resolvedSubTaskSequence != 1 && resolvedSubTaskSequence != 2))
        {
            return null;
        }

        var subTask = await _subTaskRepository.GetByIdWithDetailsAsync(subTaskId, ct);
        var locationType = subTask?.EndNode?.StorageLocationType;
        if (locationType == null)
        {
            return null;
        }

        Guid? applyActionId;
        Guid? completeActionId;
        if (resolvedSubTaskSequence == 1)
        {
            // 取货任务：取货申请 / 取货完成
            applyActionId = locationType.PickupApplyRequestConfigId;
            completeActionId = locationType.PickupCompleteRequestConfigId;
        }
        else
        {
            // 放货任务：放货申请 / 放货完成
            applyActionId = locationType.DropApplyRequestConfigId;
            completeActionId = locationType.DropCompleteRequestConfigId;
        }

        if (!applyActionId.HasValue && !completeActionId.HasValue)
        {
            return null;
        }

        return new TerminalLocationActionContext(applyActionId, completeActionId);
    }

    /// <summary>
    /// 终点库位事件上下文（申请/完成）。
    /// </summary>
    private sealed class TerminalLocationActionContext
    {
        public TerminalLocationActionContext(Guid? applyActionId, Guid? completeActionId)
        {
            ApplyActionId = applyActionId;
            CompleteActionId = completeActionId;
        }

        /// <summary>
        /// 申请事件ID（取货申请或放货申请）。
        /// </summary>
        public Guid? ApplyActionId { get; }
        /// <summary>
        /// 完成事件ID（取货完成或放货完成）。
        /// </summary>
        public Guid? CompleteActionId { get; }
        /// <summary>
        /// 是否存在申请事件。
        /// </summary>
        public bool HasApplyAction => ApplyActionId.HasValue;
        /// <summary>
        /// 是否存在完成事件。
        /// </summary>
        public bool HasCompleteAction => CompleteActionId.HasValue;
        /// <summary>
        /// 是否至少存在一个终点库位事件（申请或完成）。
        /// </summary>
        public bool HasAnyAction => HasApplyAction || HasCompleteAction;
    }

    /// <summary>
    /// 检查并补充虚拟原地路径：
    /// 1. 保留资源边界首段 Pre-Apply 的起点虚拟段逻辑；
    /// 2. 按终点库位事件规则，在终点后补充 V1/V2 虚拟段并挂载申请/完成事件。
    ///
    /// 当首段存在资源边界 Pre-Apply 动作，且缺少“前一条原子路径”承载点时，
    /// 在路径起点生成一段虚拟原地路径作为独立的二级列表
    ///
    /// 生成规则（仅资源边界，不含任务模板）：
    /// - 第一条原子路径发生资源边界切换，且存在以下任一动作时生成虚拟路径：
    ///   1. 进入资源时的 Pre1(Apply)
    ///   2. 离开资源时的 Pre2(Apply)
    ///
    /// 虚拟路径特征：
    /// - 作为独立的二级列表插入到第一个一级列表的开头
    /// - EdgeId = Guid.Empty（无实际边）
    /// - FromNodeId = ToNodeId = 起点节点ID
    /// - Length = 0
    ///
    /// @author zzy
    /// 2026-02-07 创建
    /// 2026-02-07 更新：虚拟路径作为独立二级列表插入
    /// 2026-03-28 更新：移除模板判断，改为资源边界 Pre-Apply 判断
    /// 2026-03-30 更新：新增终点库位事件矩阵（仅申请 / 仅完成 / 申请+完成）
    /// </summary>
    private bool EnsureVirtualSegmentForApplyActions(
        List<List<List<PathSegmentWithCode>>>? segmentedPath,
        PathRequest request,
        PathGraph graph,
        TerminalLocationActionContext? terminalActionContext)
    {

        if (segmentedPath == null || segmentedPath.Count == 0)
        {
            return true;
        }

        // 将三层结构展平为原子路径列表
        var flatSegments = segmentedPath
            .SelectMany(junction => junction.SelectMany(resource => resource))
            .ToList();

        if (flatSegments.Count == 0)
        {
            return true;
        }

        // 资源边界首段虚拟路径：已存在时不重复插入
        var firstSegment = flatSegments[0];
        var hasStartVirtualSegment = firstSegment.EdgeId == Guid.Empty &&
                                     firstSegment.FromNodeId == firstSegment.ToNodeId;
        if (!hasStartVirtualSegment)
        {
            // 检查是否需要生成虚拟路径（仅资源边界 Pre-Apply）
            var needVirtualSegment = CheckNeedVirtualSegment(flatSegments, graph);
            if (needVirtualSegment)
            {
                if (!graph.Nodes.TryGetValue(request.StartNodeId, out var startNode) || startNode == null)
                {
                    _logger.LogWarning("VDA5050 - 补充虚拟路径失败，起点节点 {StartNodeId} 在图结构中不存在", request.StartNodeId);
                    return false;
                }

                // 创建独立的二级列表，只包含虚拟路径段
                var virtualResourceGroup = new List<PathSegmentWithCode>
                {
                    CreateInPlaceVirtualSegment(request.StartNodeId, startNode.NodeCode, theta: 0)
                };

                // 将虚拟二级列表插入到第一个一级列表的开头
                segmentedPath[0].Insert(0, virtualResourceGroup);
            }
        }

        // 终点库位事件：统一在终点后补虚拟段并按规则挂载
        if (terminalActionContext is not { HasAnyAction: true })
        {
            return true;
        }

        flatSegments = segmentedPath
            .SelectMany(junction => junction.SelectMany(resource => resource))
            .ToList();
        if (flatSegments.Count == 0)
        {
            return true;
        }

        var terminalRealSegmentIndex = GetTerminalRealSegmentIndex(flatSegments);
        if (terminalRealSegmentIndex < 0 || terminalRealSegmentIndex >= flatSegments.Count)
        {
            return true;
        }

        var terminalRealSegment = flatSegments[terminalRealSegmentIndex];
        var terminalNodeId = terminalRealSegment.ToNodeId;
        if (!graph.Nodes.TryGetValue(terminalNodeId, out var terminalNode) || terminalNode == null)
        {
            _logger.LogWarning("VDA5050 - 补充终点虚拟路径失败，终点节点 {TerminalNodeId} 在图结构中不存在", terminalNodeId);
            return false;
        }

        // 申请事件固定挂在“真实终点段”。
        if (terminalActionContext.ApplyActionId.HasValue)
        {
            terminalRealSegment.EndNodeNetActionTypes[terminalActionContext.ApplyActionId.Value] = ActionType.Apply;
        }

        // 终点虚拟段数量规则：
        // - 仅申请：生成 1 段（V1）
        // - 仅完成：生成 1 段（V1）
        // - 申请+完成：生成 2 段（V1、V2）
        var requiredTrailingVirtualCount =
            (terminalActionContext.HasApplyAction ? 1 : 0) +
            (terminalActionContext.HasCompleteAction ? 1 : 0);

        var trailingVirtualCount = GetTrailingTerminalVirtualCount(flatSegments);
        while (trailingVirtualCount < requiredTrailingVirtualCount)
        {
            if (segmentedPath[^1].Count == 0)
            {
                segmentedPath[^1].Add(new List<PathSegmentWithCode>());
            }

            // 终点后追加原地虚拟段（From=To=终点），用于承载终点矩阵中的后续动作/事件。
            var virtualResourceGroup = new List<PathSegmentWithCode>
            {
                CreateInPlaceVirtualSegment(terminalNodeId, terminalNode.NodeCode, terminalRealSegment.EndTheta)
            };
            segmentedPath[^1].Add(virtualResourceGroup);
            trailingVirtualCount++;
        }

        if (terminalActionContext.CompleteActionId.HasValue)
        {
            flatSegments = segmentedPath
                .SelectMany(junction => junction.SelectMany(resource => resource))
                .ToList();

            terminalRealSegmentIndex = GetTerminalRealSegmentIndex(flatSegments);
            // 完成事件挂载矩阵：
            // - 仅完成：挂 V1（offset=1）
            // - 申请+完成：挂 V2（offset=2）
            var completeTargetOffset = terminalActionContext.HasApplyAction ? 2 : 1;
            var completeTargetIndex = terminalRealSegmentIndex + completeTargetOffset;
            if (completeTargetIndex < 0 || completeTargetIndex >= flatSegments.Count)
            {
                _logger.LogWarning(
                    "VDA5050 - 完成事件挂载失败，目标虚拟段不存在: TerminalIndex={TerminalIndex}, TargetIndex={TargetIndex}",
                    terminalRealSegmentIndex,
                    completeTargetIndex);
                return false;
            }

            flatSegments[completeTargetIndex].EndNodeNetActionTypes[terminalActionContext.CompleteActionId.Value] =
                ActionType.Apply;
        }

        return true;
    }

    /// <summary>
    /// 创建原地虚拟路径段（From=To，同节点）。
    /// </summary>
    private static PathSegmentWithCode CreateInPlaceVirtualSegment(Guid nodeId, string nodeCode, double theta)
    {
        return new PathSegmentWithCode
        {
            EdgeId = Guid.Empty,
            FromNodeId = nodeId,
            ToNodeId = nodeId,
            FromNodeCode = nodeCode,
            ToNodeCode = nodeCode,
            EdgeCode = string.Empty,
            Angle = 0,
            Length = 0,
            MaxSpeed = null,
            StartTheta = theta,
            EndTheta = theta
        };
    }

    /// <summary>
    /// 获取“真实终点段”在展平路径中的索引。
    /// 会跳过尾部已追加的终点原地虚拟段（V1/V2）。
    /// 特别约束：
    /// - 至少保留 1 条真实段，避免“原始路径本身就是原地段(N1->N1)”时被误判为虚拟段。
    /// </summary>
    private static int GetTerminalRealSegmentIndex(IReadOnlyList<PathSegmentWithCode> segments)
    {
        if (segments.Count == 0) return -1;

        var terminalNodeId = segments[^1].ToNodeId;
        var index = segments.Count - 1;
        // 只在 index > 0 时回退，保证至少留下第 0 条作为真实终点段。
        while (index > 0 && IsTerminalInPlaceVirtualSegment(segments[index], terminalNodeId))
        {
            index--;
        }

        return index >= 0 ? index : segments.Count - 1;
    }

    /// <summary>
    /// 统计尾部与终点同节点的原地虚拟段数量（V1/V2...）。
    /// 统计口径：总段数 - 真实终点段索引 - 1。
    /// 这样可以避免把“原始真实原地段(N1->N1)”计入虚拟段数量。
    /// </summary>
    private static int GetTrailingTerminalVirtualCount(IReadOnlyList<PathSegmentWithCode> segments)
    {
        if (segments.Count == 0)
        {
            return 0;
        }

        var terminalRealSegmentIndex = GetTerminalRealSegmentIndex(segments);
        if (terminalRealSegmentIndex < 0 || terminalRealSegmentIndex >= segments.Count)
        {
            return 0;
        }

        return Math.Max(0, segments.Count - terminalRealSegmentIndex - 1);
    }

    /// <summary>
    /// 判断是否为“终点原地虚拟段”（EdgeId=Empty 且 From/To 均为终点）。
    /// </summary>
    private static bool IsTerminalInPlaceVirtualSegment(PathSegmentWithCode segment, Guid terminalNodeId)
    {
        return segment.EdgeId == Guid.Empty &&
               segment.FromNodeId == terminalNodeId &&
               segment.ToNodeId == terminalNodeId;
    }

    /// <summary>
    /// 检查是否需要生成虚拟路径
    ///
    /// 判断规则（仅资源边界）：
    /// 第一条原子路径发生资源边界切换，且包含 Pre1(Apply) 或 Pre2(Apply) 动作时，
    /// 需要生成虚拟路径作为“前一条路径”的承载位置。
    ///
    /// @author zzy
    /// 2026-02-07 创建
    /// 2026-03-28 更新：移除模板判断，改为首段资源边界 Pre-Apply 判断
    /// </summary>
    private static bool CheckNeedVirtualSegment(
        IReadOnlyList<PathSegmentWithCode> flatSegments,
        PathGraph graph)
    {
        if (flatSegments.Count == 0)
        {
            return false;
        }

        var firstSeg = flatSegments[0];
        var resourceLookup = BuildNodeResourceLookup(graph);
        var resourceByCode = graph.Resources
            .Where(r => CuttingResourceTypes.Contains(r.Type))
            .ToDictionary(r => r.ResourceCode, StringComparer.OrdinalIgnoreCase);

        var fromRes = resourceLookup.TryGetValue(firstSeg.FromNodeId, out var fr) ? fr : new HashSet<string>();
        var toRes = resourceLookup.TryGetValue(firstSeg.ToNodeId, out var tr) ? tr : new HashSet<string>();

        // 进入资源：检查 Pre1(Apply)
        foreach (var resCode in toRes.Except(fromRes))
        {
            if (!resourceByCode.TryGetValue(resCode, out var resource))
            {
                continue;
            }

            if ((resource.PreAction1Type ?? ActionType.None) == ActionType.Apply &&
                resource.PreNetActions1 is { Count: > 0 })
            {
                return true;
            }
        }

        // 离开资源：检查 Pre2(Apply)
        foreach (var resCode in fromRes.Except(toRes))
        {
            if (!resourceByCode.TryGetValue(resCode, out var resource))
            {
                continue;
            }

            if ((resource.PreAction2Type ?? ActionType.None) == ActionType.Apply &&
                resource.PreNetActions2 is { Count: > 0 })
            {
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// 将动作装载到路径段，分两轮处理：
    /// 第一轮：Notify 动作（基于原子路径挂载）
    /// 第二轮：Apply 动作（基于场景切割集合挂载）
    ///
    /// 【Notify（消息通知）】- 不需要等待响应
    ///   - 资源边界 Notify：挂载在切换场景时原子路径的起点/终点
    ///   - 任务步骤 Notify：挂载在整个原子路径的最后三个节点上
    ///     - Node: Pre1 → 倒数第二个节点, Post1 → 最后一个节点
    ///     - PreNode: Pre1 → 倒数第三个节点, Post1 → 倒数第二条原子路径终点,
    ///               Pre2 → 倒数第二个节点, Post2 → 最后一个节点
    ///
    /// 【Apply（动作申请）】- 需要等待响应，挂载在场景集合的边界位置
    ///   - Pre（进入/离开前）：上一个场景集合最后一段路径的终点 (EndNode)
    ///   - Post（进入/离开后）：切换场景时原子路径的终点 (EndNode)
    ///
    /// @author zzy
    /// 2026-02-09 重构：拆分为 Notify 轮 + Apply 轮，规则清晰、职责单一
    /// 2026-02-09 更新：任务步骤 Notify 改为基于整个原子路径的最后三个节点挂载
    /// </summary>
    private async Task<bool> LoadActionsToSegmentsAsync(
        List<List<List<PathSegmentWithCode>>> segmentedPath,
        TaskStep? taskStep,
        PathGraph graph,
        Robot robot,
        bool addStopChargingActionAtStart,
        TerminalLocationActionContext? terminalActionContext)
    {
        if (segmentedPath.Count == 0)
        {
            _logger.LogWarning("VDA5050 - 动作装载失败，路径分段为空");
            return false;
        }

        // 将三层结构展平为单层原子路径列表
        var flatSegments = segmentedPath
            .SelectMany(junction => junction.SelectMany(resource => resource))
            .ToList();

        if (flatSegments.Count == 0)
        {
            _logger.LogWarning("VDA5050 - 动作装载失败，展平后路径为空");
            return false;
        }

        // 将二级列表展平为场景切割集合列表
        var flatSceneGroups = segmentedPath
            .SelectMany(junction => junction)
            .ToList();

        // 第一轮：挂载所有 Notify 类型动作
        LoadNotifyActions(flatSegments, taskStep, graph);

        // 第二轮：挂载所有 Apply 类型动作
        LoadApplyActions(flatSegments, flatSceneGroups, taskStep, graph);

        // 第三轮：挂载 StepAction 到最后一段的起点和终点
        await LoadStepActionsToLastSegmentAsync(
            flatSegments,
            taskStep,
            robot,
            addStopChargingActionAtStart,
            terminalActionContext);

        return true;
    }

    // ==================== 第一轮：Notify 动作挂载 ====================

    /// <summary>
    /// 第一轮：挂载所有 Notify 类型动作
    /// 遍历每个场景切换边界，将 Notify 动作挂载到原子路径的起点/终点
    ///
    /// Notify 规则：
    /// - Pre（进入/离开前）：原子路径的起点 (StartNode)
    /// - Post（进入/离开后）：原子路径的终点 (EndNode)
    ///
    /// @author zzy
    /// 2026-02-09 创建
    /// 2026-02-09 更新：任务步骤 Notify 改为基于整个原子路径的最后三个节点挂载
    /// </summary>
    private void LoadNotifyActions(
        List<PathSegmentWithCode> flatSegments,
        TaskStep? taskStep,
        PathGraph graph)
    {
        // 1. 资源边界 Notify 动作
        LoadResourceBoundaryNotifyActions(flatSegments, graph);

        // 2. 任务步骤 Notify 动作
        if (taskStep != null)
        {
            LoadTaskStepNotifyActions(flatSegments, taskStep);
        }
    }

    /// <summary>
    /// 挂载资源边界 Notify 类型动作
    ///
    /// 当机器人跨越资源区域边界时：
    /// - 进入资源：ToNode在资源内，FromNode不在资源内
    ///   - Pre1(Notify) → 当前原子路径的起点 (StartNode)
    ///   - Post1(Notify) → 当前原子路径的终点 (EndNode)
    /// - 离开资源：FromNode在资源内，ToNode不在资源内
    ///   - Pre2(Notify) → 当前原子路径的起点 (StartNode)
    ///   - Post2(Notify) → 当前原子路径的终点 (EndNode)
    ///
    /// @author zzy
    /// 2026-02-09 创建：从 LoadResourceBoundaryNetActions 拆分
    /// </summary>
    private void LoadResourceBoundaryNotifyActions(
        List<PathSegmentWithCode> flatSegments,
        PathGraph graph)
    {
        if (flatSegments.Count == 0) return;

        // 建立资源编码到资源的映射
        var resourceByCode = graph.Resources
            .Where(r => CuttingResourceTypes.Contains(r.Type))
            .ToDictionary(r => r.ResourceCode, StringComparer.OrdinalIgnoreCase);

        // 构建节点到资源编码的查找表
        var resourceLookup = BuildNodeResourceLookup(graph);

        for (var i = 0; i < flatSegments.Count; i++)
        {
            var currentSeg = flatSegments[i];
            var fromResources = resourceLookup.TryGetValue(currentSeg.FromNodeId, out var fr) ? fr : new HashSet<string>();
            var toResources = resourceLookup.TryGetValue(currentSeg.ToNodeId, out var tr) ? tr : new HashSet<string>();

            // 检测进入资源（ToNode在资源内，FromNode不在）
            var enteringResources = toResources.Except(fromResources).ToList();
            foreach (var resCode in enteringResources)
            {
                if (resourceByCode.TryGetValue(resCode, out var resource))
                {
                    // Pre1（进入前）：Notify → 当前原子路径的起点
                    if (HasNetActions(resource.PreNetActions1))
                    {
                        var type = resource.PreAction1Type ?? ActionType.None;
                        if (type == ActionType.Notify)
                        {
                            foreach (var actionId in resource.PreNetActions1!)
                            {
                                currentSeg.StartNodeNetActionTypes[actionId] = type;
                            }
                        }
                    }

                    // Post1（进入后）：Notify → 当前原子路径的终点
                    if (HasNetActions(resource.PostNetActions1))
                    {
                        var type = resource.PostAction1Type ?? ActionType.None;
                        if (type == ActionType.Notify)
                        {
                            foreach (var actionId in resource.PostNetActions1!)
                            {
                                currentSeg.EndNodeNetActionTypes[actionId] = type;
                            }
                        }
                    }
                }
            }

            // 检测离开资源（FromNode在资源内，ToNode不在）
            var exitingResources = fromResources.Except(toResources).ToList();
            foreach (var resCode in exitingResources)
            {
                if (resourceByCode.TryGetValue(resCode, out var resource))
                {
                    // Pre2（离开前）：Notify → 当前原子路径的起点
                    if (HasNetActions(resource.PreNetActions2))
                    {
                        var type = resource.PreAction2Type ?? ActionType.None;
                        if (type == ActionType.Notify)
                        {
                            foreach (var actionId in resource.PreNetActions2!)
                            {
                                currentSeg.StartNodeNetActionTypes[actionId] = type;
                            }
                        }
                    }

                    // Post2（离开后）：Notify → 当前原子路径的终点
                    if (HasNetActions(resource.PostNetActions2))
                    {
                        var type = resource.PostAction2Type ?? ActionType.None;
                        if (type == ActionType.Notify)
                        {
                            foreach (var actionId in resource.PostNetActions2!)
                            {
                                currentSeg.EndNodeNetActionTypes[actionId] = type;
                            }
                        }
                    }
                }
            }
        }
    }

    /// <summary>
    /// 挂载任务步骤 Notify 类型动作
    ///
    /// 基于整个原子路径的最后三个节点挂载：
    /// - 倒数第三个节点 = flatSegments[^2].StartNode (即 flatSegments[^2].FromNodeId)
    /// - 倒数第二个节点 = flatSegments[^2].EndNode / flatSegments[^1].StartNode
    /// - 最后一个节点   = flatSegments[^1].EndNode (即 flatSegments[^1].ToNodeId)
    ///
    /// Node（路径终点）：只有"进入"动作
    ///   - Pre1(Notify) → 倒数第二个节点 (flatSegments[^1].StartNode)
    ///   - Post1(Notify) → 最后一个节点 (flatSegments[^1].EndNode)
    ///
    /// PreNode（路径倒数第二个节点）：有"进入"和"离开"两组动作
    ///   - Pre1(Notify) → 倒数第三个节点 (flatSegments[^2].StartNode)
    ///   - Post1(Notify) → 倒数第三个原子路径的终点 (flatSegments[^2].EndNode)
    ///   - Pre2(Notify) → 倒数第二个节点 (flatSegments[^1].StartNode)
    ///   - Post2(Notify) → 最后一个节点 (flatSegments[^1].EndNode)
    ///
    /// @author zzy
    /// 2026-02-09 创建
    /// 2026-02-09 更新：改为基于整个原子路径的最后三个节点挂载
    /// </summary>
    private void LoadTaskStepNotifyActions(
        List<PathSegmentWithCode> flatSegments,
        TaskStep taskStep)
    {
        if (flatSegments.Count == 0) return;

        foreach (var prop in taskStep.Properties)
        {
            if (prop.PropertyType == StepPropertyType.Node)
            {
                LoadNodeNotifyActions(flatSegments, prop);
            }
            else if (prop.PropertyType == StepPropertyType.PreNode)
            {
                LoadPreNodeNotifyActions(flatSegments, prop);
            }
        }
    }

    /// <summary>
    /// 挂载 Node（路径终点）的 Notify 动作
    ///
    /// 基于整个原子路径的最后一条原子路径：
    /// - Pre1(Notify) → 倒数第二个节点 = flatSegments[^1].StartNode
    /// - Post1(Notify) → 最后一个节点 = flatSegments[^1].EndNode
    ///
    /// @author zzy
    /// 2026-02-09 创建
    /// 2026-02-09 更新：改为基于整个原子路径的最后节点挂载
    /// </summary>
    private void LoadNodeNotifyActions(
        List<PathSegmentWithCode> flatSegments,
        StepProperty prop)
    {
        if (flatSegments.Count < 1)
        {
            return;
        }

        // 最后一条原子路径
        var lastSegment = flatSegments[^1];

        // Pre1（进入前）：Notify → 倒数第二个节点（最后一条原子路径的起点）
        if (HasNetActions(prop.PreNetActions1))
        {
            var type = prop.PreAction1Type ?? ActionType.None;
            if (type == ActionType.Notify)
            {
                foreach (var actionId in prop.PreNetActions1!)
                {
                    lastSegment.StartNodeNetActionTypes[actionId] = type;
                }
            }
        }

        // Post1（进入后）：Notify → 最后一个节点（最后一条原子路径的终点）
        if (HasNetActions(prop.PostNetActions1))
        {
            var type = prop.PostAction1Type ?? ActionType.None;
            if (type == ActionType.Notify)
            {
                foreach (var actionId in prop.PostNetActions1!)
                {
                    lastSegment.EndNodeNetActionTypes[actionId] = type;
                }
            }
        }
    }

    /// <summary>
    /// 挂载 PreNode（路径倒数第二个节点）的 Notify 动作
    ///
    /// 基于整个原子路径的最后两条原子路径（最后三个节点）：
    /// - flatSegments[^2] = 倒数第二条原子路径
    /// - flatSegments[^1] = 最后一条原子路径
    ///
    /// 进入动作：
    /// - Pre1(Notify) → 倒数第三个节点 = flatSegments[^2].StartNode
    /// - Post1(Notify) → 倒数第三个原子路径的终点 = flatSegments[^2].EndNode
    ///
    /// 离开动作：
    /// - Pre2(Notify) → 倒数第二个节点 = flatSegments[^1].StartNode
    /// - Post2(Notify) → 最后一个节点 = flatSegments[^1].EndNode
    ///
    /// @author zzy
    /// 2026-02-09 创建
    /// 2026-02-09 更新：改为基于整个原子路径的最后三个节点挂载
    /// </summary>
    private void LoadPreNodeNotifyActions(
        List<PathSegmentWithCode> flatSegments,
        StepProperty prop)
    {
        if (flatSegments.Count < 2)
        {
            _logger.LogWarning("PreNode Notify动作装载失败：原子路径数不足，路径数: {SegmentCount}", flatSegments.Count);
            return;
        }

        // 倒数第二条原子路径（包含倒数第三个节点和倒数第二个节点）
        var secondLastSegment = flatSegments[^2];
        // 最后一条原子路径（包含倒数第二个节点和最后一个节点）
        var lastSegment = flatSegments[^1];

        // ========== 进入动作（Pre1/Post1）==========

        // Pre1（进入前）：Notify → 倒数第三个节点（倒数第二条原子路径的起点）
        if (HasNetActions(prop.PreNetActions1))
        {
            var type = prop.PreAction1Type ?? ActionType.None;
            if (type == ActionType.Notify)
            {
                foreach (var actionId in prop.PreNetActions1!)
                {
                    secondLastSegment.StartNodeNetActionTypes[actionId] = type;
                }
            }
        }

        // Post1（进入后）：Notify → 倒数第二条原子路径的终点
        if (HasNetActions(prop.PostNetActions1))
        {
            var type = prop.PostAction1Type ?? ActionType.None;
            if (type == ActionType.Notify)
            {
                foreach (var actionId in prop.PostNetActions1!)
                {
                    secondLastSegment.EndNodeNetActionTypes[actionId] = type;
                }
            }
        }

        // ========== 离开动作（Pre2/Post2）==========

        // Pre2（离开前）：Notify → 倒数第二个节点（最后一条原子路径的起点）
        if (HasNetActions(prop.PreNetActions2))
        {
            var type = prop.PreAction2Type ?? ActionType.None;
            if (type == ActionType.Notify)
            {
                foreach (var actionId in prop.PreNetActions2!)
                {
                    lastSegment.StartNodeNetActionTypes[actionId] = type;
                }
            }
        }

        // Post2（离开后）：Notify → 最后一个节点（最后一条原子路径的终点）
        if (HasNetActions(prop.PostNetActions2))
        {
            var type = prop.PostAction2Type ?? ActionType.None;
            if (type == ActionType.Notify)
            {
                foreach (var actionId in prop.PostNetActions2!)
                {
                    lastSegment.EndNodeNetActionTypes[actionId] = type;
                }
            }
        }
    }

    /// <summary>
    /// 判断是否有网络动作配置
    /// </summary>
    private bool HasNetActions(List<Guid>? netActionIds)
    {
        return netActionIds != null && netActionIds.Count > 0;
    }

    // ==================== 第二轮：Apply 动作挂载 ====================

    /// <summary>
    /// 第二轮：挂载所有 Apply 类型动作
    /// 遍历每个场景切换边界，将 Apply 动作挂载到场景集合的边界位置
    ///
    /// Apply 规则：
    /// - Pre（进入/离开前）：上一个场景集合最后一段路径的终点 (EndNode)
    /// - Post（进入/离开后）：切换场景时原子路径的终点 (EndNode)
    ///
    /// @author zzy
    /// 2026-02-09 创建
    /// </summary>
    private void LoadApplyActions(
        List<PathSegmentWithCode> flatSegments,
        List<List<PathSegmentWithCode>> flatSceneGroups,
        TaskStep? taskStep,
        PathGraph graph)
    {
        // 1. 资源边界 Apply 动作
        LoadResourceBoundaryApplyActions(flatSegments, graph);

        // 2. 任务步骤 Apply 动作
        if (taskStep != null)
        {
            LoadTaskStepApplyActions(flatSegments, flatSceneGroups, taskStep);
        }
    }

    /// <summary>
    /// 挂载资源边界 Apply 类型动作
    ///
    /// 当机器人跨越资源区域边界时：
    /// - 进入资源：ToNode在资源内，FromNode不在资源内
    ///   - Pre1(Apply) → 前一条原子路径的终点 (seg[i-1].EndNode)
    ///   - Post1(Apply) → 当前原子路径的终点 (seg[i].EndNode)
    /// - 离开资源：FromNode在资源内，ToNode不在资源内
    ///   - Pre2(Apply) → 前一条原子路径的终点 (seg[i-1].EndNode)
    ///   - Post2(Apply) → 当前原子路径的终点 (seg[i].EndNode)
    ///
    /// @author zzy
    /// 2026-02-09 创建：从 LoadResourceBoundaryNetActions 拆分
    /// </summary>
    private void LoadResourceBoundaryApplyActions(
        List<PathSegmentWithCode> flatSegments,
        PathGraph graph)
    {
        if (flatSegments.Count == 0) return;

        // 建立资源编码到资源的映射
        var resourceByCode = graph.Resources
            .Where(r => CuttingResourceTypes.Contains(r.Type))
            .ToDictionary(r => r.ResourceCode, StringComparer.OrdinalIgnoreCase);

        // 构建节点到资源编码的查找表
        var resourceLookup = BuildNodeResourceLookup(graph);

        for (var i = 0; i < flatSegments.Count; i++)
        {
            var currentSeg = flatSegments[i];
            var fromResources = resourceLookup.TryGetValue(currentSeg.FromNodeId, out var fr) ? fr : new HashSet<string>();
            var toResources = resourceLookup.TryGetValue(currentSeg.ToNodeId, out var tr) ? tr : new HashSet<string>();
            var preSegment = i > 0 ? flatSegments[i - 1] : null;

            // 检测进入资源（ToNode在资源内，FromNode不在）
            var enteringResources = toResources.Except(fromResources).ToList();
            foreach (var resCode in enteringResources)
            {
                if (resourceByCode.TryGetValue(resCode, out var resource))
                {
                    // Pre1（进入前）：Apply → 前一条原子路径的终点
                    if (HasNetActions(resource.PreNetActions1))
                    {
                        var type = resource.PreAction1Type ?? ActionType.None;
                        if (type == ActionType.Apply && preSegment != null)
                        {
                            foreach (var actionId in resource.PreNetActions1!)
                            {
                                preSegment.EndNodeNetActionTypes[actionId] = type;
                            }
                        }
                    }

                    // Post1（进入后）：Apply → 当前原子路径的终点
                    if (HasNetActions(resource.PostNetActions1))
                    {
                        var type = resource.PostAction1Type ?? ActionType.None;
                        if (type == ActionType.Apply)
                        {
                            foreach (var actionId in resource.PostNetActions1!)
                            {
                                currentSeg.EndNodeNetActionTypes[actionId] = type;
                            }
                        }
                    }
                }
            }

            // 检测离开资源（FromNode在资源内，ToNode不在）
            var exitingResources = fromResources.Except(toResources).ToList();
            foreach (var resCode in exitingResources)
            {
                if (resourceByCode.TryGetValue(resCode, out var resource))
                {
                    // Pre2（离开前）：Apply → 前一条原子路径的终点
                    if (HasNetActions(resource.PreNetActions2))
                    {
                        var type = resource.PreAction2Type ?? ActionType.None;
                        if (type == ActionType.Apply && preSegment != null)
                        {
                            foreach (var actionId in resource.PreNetActions2!)
                            {
                                preSegment.EndNodeNetActionTypes[actionId] = type;
                            }
                        }
                    }

                    // Post2（离开后）：Apply → 当前原子路径的终点
                    if (HasNetActions(resource.PostNetActions2))
                    {
                        var type = resource.PostAction2Type ?? ActionType.None;
                        if (type == ActionType.Apply)
                        {
                            foreach (var actionId in resource.PostNetActions2!)
                            {
                                currentSeg.EndNodeNetActionTypes[actionId] = type;
                            }
                        }
                    }
                }
            }
        }
    }

    /// <summary>
    /// 挂载任务步骤 Apply 类型动作
    ///
    /// Node（路径终点）：只有"进入"动作
    ///   - 进入场景 = 最后一个场景切割集合
    ///   - 前一个场景 = 倒数第二个场景切割集合
    ///   - Pre1(Apply) → 前一个场景最后一条原子路径的终点 (EndNode)
    ///   - Post1(Apply) → 进入场景第一条原子路径的终点 (EndNode)
    ///
    /// PreNode（路径倒数第二个节点）：有"进入"和"离开"两组动作
    ///   - 进入前场景 = 倒数第三个场景切割集合
    ///   - 进入场景 = 倒数第二个场景切割集合
    ///   - 离开场景 = 最后一个场景切割集合
    ///   - Pre1(Apply) → 进入前场景最后一条原子路径的终点
    ///   - Post1(Apply) → 进入场景第一条原子路径的终点
    ///   - Pre2(Apply) → 进入场景最后一条原子路径的终点
    ///   - Post2(Apply) → 离开场景第一条原子路径的终点
    ///
    /// @author zzy
    /// 2026-02-09 创建
    /// </summary>
    private void LoadTaskStepApplyActions(
        List<PathSegmentWithCode> flatSegments,
        List<List<PathSegmentWithCode>> flatSceneGroups,
        TaskStep taskStep)
    {
        if (flatSegments.Count == 0 || flatSceneGroups.Count == 0) return;

        foreach (var prop in taskStep.Properties)
        {
            if (prop.PropertyType == StepPropertyType.Node)
            {
                LoadNodeApplyActions(flatSceneGroups, prop);
            }
            else if (prop.PropertyType == StepPropertyType.PreNode)
            {
                LoadPreNodeApplyActions(flatSegments, flatSceneGroups, prop);
            }
        }
    }

    /// <summary>
    /// 挂载 Node（路径终点）的 Apply 类型动作
    ///
    /// Node 只有"进入"动作（Pre1/Post1）：
    /// - Pre1(Apply) → 前一个场景集合（倒数第二个）最后一条原子路径的终点
    /// - Post1(Apply) → 进入场景集合（最后一个）第一条原子路径的终点
    ///
    /// @author zzy
    /// 2026-02-09 创建
    /// </summary>
    private void LoadNodeApplyActions(
        List<List<PathSegmentWithCode>> flatSceneGroups,
        StepProperty prop)
    {
        // 进入场景 = 最后一个场景切割集合
        var enterSceneGroup = flatSceneGroups[^1];
        // 前一个场景 = 倒数第二个场景切割集合
        var prevSceneGroup = flatSceneGroups.Count >= 2 ? flatSceneGroups[^2] : null;

        // ========== Pre1（进入前）：Apply → 前一个场景最后一条原子路径的终点 ==========
        if (HasNetActions(prop.PreNetActions1))
        {
            var type = prop.PreAction1Type ?? ActionType.None;
            if (type == ActionType.Apply && prevSceneGroup != null && prevSceneGroup.Count > 0)
            {
                var targetSegment = prevSceneGroup[^1];
                foreach (var actionId in prop.PreNetActions1!)
                {
                    targetSegment.EndNodeNetActionTypes[actionId] = type;
                }
            }
        }

        // ========== Post1（进入后）：Apply → 进入场景第一条原子路径的终点 ==========
        if (HasNetActions(prop.PostNetActions1))
        {
            var type = prop.PostAction1Type ?? ActionType.None;
            if (type == ActionType.Apply && enterSceneGroup.Count > 0)
            {
                var targetSegment = enterSceneGroup[0];
                foreach (var actionId in prop.PostNetActions1!)
                {
                    targetSegment.EndNodeNetActionTypes[actionId] = type;
                }
            }
        }

        _logger.LogDebug("Node Apply动作装载完成，场景数: {SceneCount}, Pre1Type: {Pre1Type}, Post1Type: {Post1Type}",
            flatSceneGroups.Count, prop.PreAction1Type, prop.PostAction1Type);
    }

    /// <summary>
    /// 挂载 PreNode（路径倒数第二个节点）的 Apply 类型动作
    ///
    /// PreNode 有"进入"和"离开"两组动作：
    /// - Pre1(Apply) → 进入前场景（倒数第三个）最后一条原子路径的终点
    /// - Post1(Apply) → 进入场景（倒数第二个）第一条原子路径的终点
    /// - Pre2(Apply) → 进入场景（倒数第二个）最后一条原子路径的终点
    /// - Post2(Apply) → 离开场景（最后一个）第一条原子路径的终点
    ///
    /// @author zzy
    /// 2026-02-09 创建
    /// </summary>
    private void LoadPreNodeApplyActions(
        List<PathSegmentWithCode> flatSegments,
        List<List<PathSegmentWithCode>> flatSceneGroups,
        StepProperty prop)
    {
        if (flatSceneGroups.Count < 2 || flatSegments.Count < 2)
        {
            _logger.LogWarning("PreNode Apply动作装载失败：场景数或路径数不足，场景数: {SceneCount}, 路径数: {SegmentCount}",
                flatSceneGroups.Count, flatSegments.Count);
            return;
        }

        // 进入前场景 = 倒数第三个场景切割集合
        var preEnterSceneGroup = flatSceneGroups.Count >= 3 ? flatSceneGroups[^3] : null;
        // 进入场景 = 倒数第二个场景切割集合
        var enterSceneGroup = flatSceneGroups[^2];
        // 离开场景 = 最后一个场景切割集合
        var exitSceneGroup = flatSceneGroups[^1];

        // ========== 进入动作 ==========

        // Pre1（进入前）：Apply → 进入前场景最后一条原子路径的终点
        if (HasNetActions(prop.PreNetActions1))
        {
            var type = prop.PreAction1Type ?? ActionType.None;
            if (type == ActionType.Apply && preEnterSceneGroup != null && preEnterSceneGroup.Count > 0)
            {
                var targetSegment = preEnterSceneGroup[^1];
                foreach (var actionId in prop.PreNetActions1!)
                {
                    targetSegment.EndNodeNetActionTypes[actionId] = type;
                }
            }
        }

        // Post1（进入后）：Apply → 进入场景第一条原子路径的终点
        if (HasNetActions(prop.PostNetActions1))
        {
            var type = prop.PostAction1Type ?? ActionType.None;
            if (type == ActionType.Apply && enterSceneGroup.Count > 0)
            {
                var targetSegment = enterSceneGroup[0];
                foreach (var actionId in prop.PostNetActions1!)
                {
                    targetSegment.EndNodeNetActionTypes[actionId] = type;
                }
            }
        }

        // ========== 离开动作 ==========

        // Pre2（离开前）：Apply → 进入场景最后一条原子路径的终点
        if (HasNetActions(prop.PreNetActions2))
        {
            var type = prop.PreAction2Type ?? ActionType.None;
            if (type == ActionType.Apply && enterSceneGroup.Count > 0)
            {
                var targetSegment = enterSceneGroup[^1];
                foreach (var actionId in prop.PreNetActions2!)
                {
                    targetSegment.EndNodeNetActionTypes[actionId] = type;
                }
            }
        }

        // Post2（离开后）：Apply → 离开场景第一条原子路径的终点
        if (HasNetActions(prop.PostNetActions2))
        {
            var type = prop.PostAction2Type ?? ActionType.None;
            if (type == ActionType.Apply && exitSceneGroup.Count > 0)
            {
                var targetSegment = exitSceneGroup[0];
                foreach (var actionId in prop.PostNetActions2!)
                {
                    targetSegment.EndNodeNetActionTypes[actionId] = type;
                }
            }
        }

        _logger.LogDebug("PreNode Apply动作装载完成，场景数: {SceneCount}, Pre1Type: {Pre1Type}, Post1Type: {Post1Type}, Pre2Type: {Pre2Type}, Post2Type: {Post2Type}",
            flatSceneGroups.Count, prop.PreAction1Type, prop.PostAction1Type, prop.PreAction2Type, prop.PostAction2Type);
    }

    // ==================== 第三轮：StepAction 动作挂载 ====================

    /// <summary>
    /// 第三轮：将 StepAction 挂载到原子路径最后一段的起点和终点
    ///
    /// 挂载规则：
    /// - 所有 StepAction 都挂载到最后一段的起点和终点
    /// - 堵塞类型使用任务模板中 StepAction 对应的值
    /// - 其他值（ActionName 等）使用 ActionConfiguration 中的值
    /// - 参数使用 ActionConfiguration.Parameters 中的定义
    ///
    /// @author zzy
    /// 2026-02-09 创建
    /// 2026-02-09 更新：使用 StepActionWithParams 携带参数
    /// </summary>
    private async Task LoadStepActionsToLastSegmentAsync(
        List<PathSegmentWithCode> flatSegments,
        TaskStep? taskStep,
        Robot robot,
        bool addStopChargingActionAtStart,
        TerminalLocationActionContext? terminalActionContext)
    {
        if (flatSegments.Count == 0)
        {
            return;
        }

        // 默认挂载目标为“真实终点段”；当申请+完成同时存在时，挂载到第一个终点虚拟段（V1）。
        var lastSegment = ResolveStepActionTargetSegment(flatSegments, terminalActionContext);
        var firstSegment = flatSegments[0];

        var preNodeProperties = taskStep?.Properties
            .Where(p => p.PropertyType == StepPropertyType.PreNode)
            .ToList() ?? new List<StepProperty>();

        // 按 PropertyType 分组获取 StepAction
        // PreNode（前置节点）动作 → 挂载到最后一段的起点
        // Node（节点）动作 → 挂载到最后一段的终点
        var preNodeActions = preNodeProperties
            .SelectMany(p => p.Actions)
            .OrderBy(a => a.Order)
            .ToList();

        var nodeActions = taskStep?.Properties
            .Where(p => p.PropertyType == StepPropertyType.Node)
            .SelectMany(p => p.Actions)
            .OrderBy(a => a.Order)
            .ToList() ?? new List<StepAction>();

        StepAction? stopChargingAction = null;
        if (addStopChargingActionAtStart)
        {
            var hasExistingStopChargingAction = preNodeActions.Any(a => a.Type == ActionCategory.StopCharging)
                                                || firstSegment.StartNodeActions.Any(a => a.Type == ActionCategory.StopCharging);
            if (!hasExistingStopChargingAction)
            {
                stopChargingAction = await BuildStopChargingPreActionAsync(
                    robot,
                    preNodeProperties.FirstOrDefault()?.PropertyId);
            }
        }

        if (preNodeActions.Count == 0 && nodeActions.Count == 0 && stopChargingAction == null)
        {
            return;
        }

        _logger.LogInformation(
            "开始挂载 StepAction 到最后一段，路径段数: {SegmentCount}, 前置点动作数: {PreNodeCount}, 节点动作数: {NodeCount}, 增加取消充电动作: {HasStopChargingAction}",
            flatSegments.Count, preNodeActions.Count, nodeActions.Count, stopChargingAction != null);

        if (stopChargingAction != null)
        {
            var firstNodeOrderOffset = 0;
            if (firstSegment.StartNodeActions.Count > 0)
            {
                var minOrder = firstSegment.StartNodeActions.Min(a => a.Order);
                firstNodeOrderOffset = Math.Max(0, 2 - minOrder);
            }

            if (firstNodeOrderOffset > 0)
            {
                foreach (var action in firstSegment.StartNodeActions)
                {
                    action.Order += firstNodeOrderOffset;
                }
            }

            firstSegment.StartNodeActions.Add(stopChargingAction);
        }

        // 前置点动作挂载到最后一段原子路径的起点
        foreach (var stepAction in preNodeActions)
        {
            var actionToAdd = new StepAction
            {
                ActionId = stepAction.ActionId,
                ActionConfigId = stepAction.ActionConfigId,
                PropertyId = stepAction.PropertyId,
                Type = stepAction.Type,
                ActionName = stepAction.ActionName ?? stepAction.Type.ToString(),
                Description = stepAction.Description,
                Order = stepAction.Order,
                BlockingType = stepAction.BlockingType,
                CreatedAt = stepAction.CreatedAt,
                UpdatedAt = stepAction.UpdatedAt
            };
            lastSegment.StartNodeActions.Add(actionToAdd);
        }

        // 节点动作挂载到最后一段原子路径的终点
        foreach (var stepAction in nodeActions)
        {
            var actionToAdd = new StepAction
            {
                ActionId = stepAction.ActionId,
                ActionConfigId = stepAction.ActionConfigId,
                PropertyId = stepAction.PropertyId,
                Type = stepAction.Type,
                ActionName = stepAction.ActionName ?? stepAction.Type.ToString(),
                Description = stepAction.Description,
                Order = stepAction.Order,
                BlockingType = stepAction.BlockingType,
                CreatedAt = stepAction.CreatedAt,
                UpdatedAt = stepAction.UpdatedAt
            };
            lastSegment.EndNodeActions.Add(actionToAdd);
        }
    }

    /// <summary>
    /// 解析 StepAction 的挂载目标段。
    /// 矩阵规则：
    /// - 仅申请：挂真实终点段
    /// - 仅完成：挂真实终点段
    /// - 申请+完成：挂第一个终点虚拟段（V1）
    /// </summary>
    private static PathSegmentWithCode ResolveStepActionTargetSegment(
        IReadOnlyList<PathSegmentWithCode> flatSegments,
        TerminalLocationActionContext? terminalActionContext)
    {
        if (flatSegments.Count == 0)
        {
            throw new InvalidOperationException("路径段集合为空，无法解析 StepAction 挂载目标");
        }

        var terminalRealSegmentIndex = GetTerminalRealSegmentIndex(flatSegments);
        if (terminalRealSegmentIndex < 0 || terminalRealSegmentIndex >= flatSegments.Count)
        {
            return flatSegments[^1];
        }

        // 矩阵规则：
        // 1) 仅申请    -> step_action 挂在真实终点
        // 2) 仅完成    -> step_action 挂在真实终点
        // 3) 申请+完成 -> step_action 挂在 V1
        if (terminalActionContext is { HasApplyAction: true, HasCompleteAction: true })
        {
            var v1Index = terminalRealSegmentIndex + 1;
            if (v1Index >= 0 && v1Index < flatSegments.Count)
            {
                return flatSegments[v1Index];
            }
        }

        return flatSegments[terminalRealSegmentIndex];
    }

    /// <summary>
    /// 构建“取消充电”前置动作（PreAction1）。
    /// 根据机器人供应商与类型筛选 StopCharging 动作配置。
    /// </summary>
    private async Task<StepAction?> BuildStopChargingPreActionAsync(Robot robot, Guid? propertyId)
    {
        var configs = await _actionConfigurationRepository.GetByManufacturerAndTypeAsync(
            robot.RobotManufacturer,
            robot.RobotType,
            ActionCategory.StopCharging);

        var config = configs
            .Where(c => c.IsEnabled && !string.IsNullOrWhiteSpace(c.ActionName))
            .OrderBy(c => c.SortOrder)
            .ThenBy(c => c.ActionName)
            .FirstOrDefault();

        if (config == null)
        {
            _logger.LogWarning(
                "未找到可用的停止充电动作配置，无法添加取消充电动作: Manufacturer={Manufacturer}, RobotType={RobotType}",
                robot.RobotManufacturer,
                robot.RobotType);
            return null;
        }

        return new StepAction
        {
            ActionId = Guid.NewGuid(),
            ActionConfigId = config.ActionConfigId,
            PropertyId = propertyId ?? Guid.Empty,
            Type = config.ActionCategory,
            ActionName = config.ActionName,
            Description = string.IsNullOrWhiteSpace(config.ActionDescription) ? "取消充电" : config.ActionDescription,
            Order = 1,
            BlockingType = config.BlockingType,
            CreatedAt = DateTime.Now,
            UpdatedAt = DateTime.Now
        };
    }

    /// <summary>
    /// 根据 StepAction 列表获取对应的 ActionConfiguration
    /// </summary>
    private async Task<List<ActionConfiguration>> GetActionConfigurationsAsync(List<StepAction> stepActions)
    {
        var configs = new List<ActionConfiguration>();
        var distinctIds = stepActions.Select(a => a.ActionConfigId).Distinct().ToList();

        foreach (var distinctId in distinctIds)
        {
            // 尝试通过动作名称查找
            var config = await _actionConfigurationRepository.GetByIdAsync(distinctId);
            if (config != null)
            {
                configs.Add(config);
                continue;
            }
        }

        return configs;
    }

    /// <summary>
    /// 根据图连通性识别路口节点（度数 >= 3）。
    /// </summary>
    private static HashSet<Guid> GetJunctionNodes(PathGraph graph)
    {
        var nodeNeighbors = new Dictionary<Guid, HashSet<Guid>>();
        var undirectedEdges = new HashSet<(Guid A, Guid B)>();

        foreach (var edge in graph.Edges.Values)
        {
            // 统计度数时将边视为无向边，逆向边只计一次。
            var a = edge.FromNodeId;
            var b = edge.ToNodeId;
            var key = a.CompareTo(b) <= 0 ? (a, b) : (b, a);
            if (!undirectedEdges.Add(key))
            {
                continue;
            }
            AddNeighbor(nodeNeighbors, edge.FromNodeId, edge.ToNodeId);
            AddNeighbor(nodeNeighbors, edge.ToNodeId, edge.FromNodeId);
        }

        return nodeNeighbors
            .Where(kv => kv.Value.Count >= 3)
            .Select(kv => kv.Key)
            .ToHashSet();
    }

    /// <summary>
    /// 为节点添加相邻关系，必要时初始化集合。
    /// </summary>
    private static void AddNeighbor(Dictionary<Guid, HashSet<Guid>> dict, Guid nodeId, Guid neighborId)
    {
        if (!dict.TryGetValue(nodeId, out var set))
        {
            set = new HashSet<Guid>();
            dict[nodeId] = set;
        }
        set.Add(neighborId);
    }

    /// <summary>
    /// 构建"节点 -> 资源编码集合"的查找表，用于资源边界判断。
    /// 使用几何点在多边形内判断来确定节点所属的资源区域。
    /// 节点可属于多个资源区域。
    /// @author zzy
    /// </summary>
    private static Dictionary<Guid, HashSet<string>> BuildNodeResourceLookup(PathGraph graph)
    {
        var lookup = new Dictionary<Guid, HashSet<string>>();

        // 过滤出需要进行切割判断的资源区域
        var cuttingResources = graph.Resources
            .Where(r => CuttingResourceTypes.Contains(r.Type) && r.LocationCoordinates != null && r.LocationCoordinates.Count >= 3)
            .ToList();

        foreach (var node in graph.Nodes.Values)
        {
            var resourceCodes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            foreach (var resource in cuttingResources)
            {
                if (IsPointInPolygon(node.X, node.Y, resource.LocationCoordinates!))
                {
                    resourceCodes.Add(resource.ResourceCode);
                }
            }

            if (resourceCodes.Count > 0)
            {
                lookup[node.NodeId] = resourceCodes;
            }
        }

        return lookup;
    }

    /// <summary>
    /// 判断点是否在多边形内（射线法）
    /// @author zzy
    /// </summary>
    /// <param name="x">点的X坐标</param>
    /// <param name="y">点的Y坐标</param>
    /// <param name="polygon">多边形顶点列表（按顺序组成封闭多边形）</param>
    /// <returns>点是否在多边形内</returns>
    private static bool IsPointInPolygon(double x, double y, List<PointCache> polygon)
    {
        if (polygon == null || polygon.Count < 3)
            return false;

        var inside = false;
        var j = polygon.Count - 1;

        for (var i = 0; i < polygon.Count; i++)
        {
            var xi = polygon[i].X;
            var yi = polygon[i].Y;
            var xj = polygon[j].X;
            var yj = polygon[j].Y;

            // 射线法：检查从点向右发出的水平射线与多边形边的交点数
            if (((yi > y) != (yj > y)) && (x < (xj - xi) * (y - yi) / (yj - yi) + xi))
            {
                inside = !inside;
            }

            j = i;
        }

        return inside;
    }

    private List<PathSegmentWithCode> BuildSweptLockCandidates(
        List<PathSegmentWithCode> baseSegments,
        PathGraph graph,
        Robot robot)
    {
        if (baseSegments.Count == 0)
        {
            return baseSegments;
        }

        var nodeLookup = SweptAreaCoverageResolver.BuildNodeLookup(graph);
        var edgePolylineLookup = SweptAreaCoverageResolver.BuildEdgePolylineLookup(graph);
        var centerLine = SweptAreaCoverageResolver.BuildPolylineFromSegments(
            baseSegments,
            nodeLookup,
            edgePolylineLookup);
        if (centerLine.Count == 0)
        {
            return baseSegments;
        }

        var dimensions = SweptAreaCoverageResolver.ResolveDimensions(
            robot.Width,
            robot.Length,
            robot.SafetyDistance,
            robot.CoordinateScale);
        var radius = SweptAreaCoverageResolver.CalculateSweepRadius(
            dimensions.Length,
            dimensions.Width,
            dimensions.SafetyDistance);
        var coverage = SweptAreaCoverageResolver.ExpandFromGraph(graph, centerLine, radius);
        return MergeCoverageIntoLockSegments(baseSegments, graph, coverage);
    }

    private static List<PathSegmentWithCode> MergeCoverageIntoLockSegments(
        List<PathSegmentWithCode> baseSegments,
        PathGraph graph,
        SweptAreaCoverageResult coverage)
    {
        var result = new List<PathSegmentWithCode>(baseSegments);
        var nodeCodes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        var edgeCodes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        foreach (var segment in baseSegments)
        {
            if (!string.IsNullOrWhiteSpace(segment.FromNodeCode))
            {
                nodeCodes.Add(segment.FromNodeCode);
            }

            if (!string.IsNullOrWhiteSpace(segment.ToNodeCode))
            {
                nodeCodes.Add(segment.ToNodeCode);
            }

            if (!string.IsNullOrWhiteSpace(segment.EdgeCode))
            {
                edgeCodes.Add(segment.EdgeCode);
            }
        }

        var nodeByCode = graph.Nodes.Values
            .Where(n => !string.IsNullOrWhiteSpace(n.NodeCode))
            .GroupBy(n => n.NodeCode, StringComparer.OrdinalIgnoreCase)
            .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);

        var edgeByCode = graph.Edges.Values
            .Where(e => !string.IsNullOrWhiteSpace(e.EdgeCode))
            .GroupBy(e => e.EdgeCode, StringComparer.OrdinalIgnoreCase)
            .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);

        foreach (var edgeCode in coverage.EdgeCodes)
        {
            if (edgeCodes.Contains(edgeCode) || !edgeByCode.TryGetValue(edgeCode, out var edge))
            {
                continue;
            }

            result.Add(new PathSegmentWithCode
            {
                EdgeId = edge.EdgeId,
                EdgeCode = edge.EdgeCode,
                FromNodeId = edge.FromNodeId,
                ToNodeId = edge.ToNodeId,
                FromNodeCode = edge.FromNodeCode,
                ToNodeCode = edge.ToNodeCode
            });

            edgeCodes.Add(edgeCode);
            if (!string.IsNullOrWhiteSpace(edge.FromNodeCode))
            {
                nodeCodes.Add(edge.FromNodeCode);
            }

            if (!string.IsNullOrWhiteSpace(edge.ToNodeCode))
            {
                nodeCodes.Add(edge.ToNodeCode);
            }
        }

        foreach (var nodeCode in coverage.NodeCodes)
        {
            if (nodeCodes.Contains(nodeCode) || !nodeByCode.TryGetValue(nodeCode, out var node))
            {
                continue;
            }

            result.Add(new PathSegmentWithCode
            {
                EdgeId = Guid.Empty,
                EdgeCode = string.Empty,
                FromNodeId = node.NodeId,
                ToNodeId = node.NodeId,
                FromNodeCode = node.NodeCode,
                ToNodeCode = node.NodeCode
            });

            nodeCodes.Add(nodeCode);
        }

        return result;
    }

    /// <summary>
    /// 创建即时动作消息（无参数）
    /// 每次创建时递增 robot.HeaderId
    /// @author zzy
    /// 2026-02-11 更新：递增 HeaderId
    /// </summary>
    private InstantAction CreateInstantAction(Robot robot, string actionType)
    {
        var action = new Domain.Models.VDA5050.Action
        {
            ActionId = Guid.NewGuid().ToString(),
            ActionType = actionType,
            BlockingType = "HARD"
        };

        return CreateInstantAction(robot, new List<Domain.Models.VDA5050.Action> { action });
    }

    /// <summary>
    /// 创建即时动作消息（批量动作）
    /// </summary>
    private InstantAction CreateInstantAction(Robot robot, List<Domain.Models.VDA5050.Action> actions)
    {
        robot.HeaderId++;

        return new InstantAction(
            (int)robot.HeaderId,
            robot.ProtocolVersion,
            robot.RobotManufacturer,
            robot.RobotSerialNumber,
            actions);
    }

    /// <summary>
    /// 判断当前资源段是否为原地路径（无实际移动）
    /// </summary>
    private static bool IsInPlaceSegments(List<PathSegmentWithCode> segments)
    {
        if (segments.Count == 0)
        {
            return false;
        }

        return segments.All(seg =>
            seg.FromNodeId == seg.ToNodeId &&
            Math.Abs(seg.Length) < 0.000001);
    }

    /// <summary>
    /// 将原地路径段中的节点动作转换为即时动作
    /// </summary>
    private async Task<InstantAction?> BuildInstantActionFromInPlaceSegmentsAsync(
        Robot robot,
        RobotSubTask subTask,
        List<PathSegmentWithCode> segments,
        CancellationToken ct)
    {
        var orderedStepActions = new List<StepAction>();
        var actionIds = new HashSet<Guid>();

        var firstSegment = segments[0];
        foreach (var action in firstSegment.StartNodeActions.OrderBy(a => a.Order))
        {
            if (actionIds.Add(action.ActionId))
            {
                orderedStepActions.Add(action);
            }
        }

        foreach (var segment in segments)
        {
            foreach (var action in segment.EndNodeActions.OrderBy(a => a.Order))
            {
                if (actionIds.Add(action.ActionId))
                {
                    orderedStepActions.Add(action);
                }
            }
        }

        if (orderedStepActions.Count == 0)
        {
            return null;
        }

        var context = new ParameterResolveContext
        {
            Robot = robot,
            SubTask = subTask
        };
        var actions = await ConvertStepActionsToVdaActionsAsync(orderedStepActions, context, ct);
        if (actions.Count == 0)
        {
            return null;
        }

        return CreateInstantAction(robot, actions);
    }

    /// <summary>
    /// 机器人暂停控制（当前为占位实现）。
    /// </summary>
    public Task RobotPauseAsync(Robot robot, CancellationToken ct = default)
    {
        throw new NotImplementedException();
    }

    /// <summary>
    /// 机器人继续控制（当前为占位实现）。
    /// </summary>
    public Task RobotUnPauseAsync(Robot robot, CancellationToken ct = default)
    {
        throw new NotImplementedException();
    }

    /// <summary>
    /// 机器人重定位控制（当前为占位实现）。
    /// </summary>
    public async Task<ApiResponse> ReLocationAsync(Robot robot,string mapCode, double x, double y, double theta, CancellationToken ct = default)
    {
        return ApiResponse.Successful();
    }

    /// <summary>
    /// 发送下一段路径指令
    /// 从已缓存的分段路径中获取下一段并发送
    /// @author zzy
    /// 2026-02-05 更新：支持两层切割结构（路口段 + 资源段）
    /// 2026-02-06 更新：添加分布式锁防止并发重复发送
    /// </summary>
    /// <param name="robot">机器人实体</param>
    /// <param name="currentSubTask">子任务实体</param>
    /// <param name="ct">取消令牌</param>
    /// <param name="reExec">是否为重新执行</param>
    /// <returns>操作响应</returns>
    public async Task<ApiResponse> SendNextSegmentAsync(Robot robot, RobotSubTask currentSubTask, CancellationToken ct = default, bool reExec = false)
    {
        // 尝试获取分布式锁，防止并发重复发送
        var lockKey = $"send_segment_lock:{robot.RobotId}";
        var lockAcquired = await _redis.GetDatabase().StringSetAsync(
            lockKey, "1", TimeSpan.FromSeconds(10), When.NotExists);

        if (!lockAcquired)
        {
            _logger.LogInformation("[段发送] 其他进程正在发送路径段，跳过: RobotId={RobotId}", robot.RobotId);
            return ApiResponse.Failed("路径段发送正在进行中");
        }

        try
        {
            return await SendNextSegmentInternalAsync(robot, currentSubTask, ct, reExec);
        }
        finally
        {
            // 释放锁
            await _redis.GetDatabase().KeyDeleteAsync(lockKey);
        }
    }

    /// <summary>
    /// 发送下一段路径指令的内部实现（无锁版本，供 SendNextSegmentAsync 调用）
    /// @author zzy
    /// 2026-02-06 更新：添加网络动作执行检查
    /// </summary>
    private async Task<ApiResponse> SendNextSegmentInternalAsync(Robot robot, RobotSubTask currentSubTask, CancellationToken ct, bool reExec)
    {
        _logger.LogInformation("VDA5050 - 发送下一段路径，机器人: {SerialNumber}, 任务: {TaskCode}",
            robot.RobotSerialNumber, currentSubTask.SubTaskId);

        // 从 Redis 获取缓存的分段路径
        var key = $"{_settings.Redis.KeyPrefixes.VdaPath}:{robot.RobotId}:{currentSubTask.TaskId}:{currentSubTask.SubTaskId}";
        var cacheData = await _redis.GetDatabase().StringGetAsync(key);
        if (cacheData.IsNullOrEmpty)
        {
            return ApiResponse.Failed("VDA5050 - 未找到缓存的路径数据");
        }

        var cache = JsonSerializer.Deserialize<VdaSegmentedPathCache>(cacheData.ToString());
        if (cache == null)
        {
            return ApiResponse.Failed("VDA5050 - 路径缓存反序列化失败");
        }

        var db = _redis.GetDatabase();
        var expectedPlanVersion = cache.PlanVersion;
        await EnsurePathPlanVersionKeyAsync(db, key, expectedPlanVersion);

        var inHoldWindow =
            (string.Equals(cache.RouteMode, RouteModeHold, StringComparison.Ordinal) ||
             string.Equals(cache.RouteMode, RouteModeQueue, StringComparison.Ordinal) ||
             string.Equals(cache.RouteMode, RouteModeOccupying, StringComparison.Ordinal) ||
             string.Equals(cache.RouteMode, RouteModeReplanPending, StringComparison.Ordinal) ||
             string.Equals(cache.RouteMode, RouteModeBlocked, StringComparison.Ordinal)) &&
            cache.HoldUntilUtc.HasValue &&
            cache.HoldUntilUtc.Value > DateTime.Now;

        if (!reExec && inHoldWindow)
        {
            await ScheduleResumeDispatchAsync(robot, currentSubTask, key, cache, expectedPlanVersion, ct);
            return ApiResponse.Successful("等待窗口未到，保持等待");
        }

        if (!reExec)
        {
            var status = await _robotCacheService.GetStatusAsync(
                robot.RobotManufacturer,
                robot.RobotSerialNumber);

            var decision = await _globalNavigationCoordinator.TryAdjustBeforeSendAsync(
                robot.RobotId,
                cache,
                status?.LastNode,
                status?.Driving ?? false,
                ct);

            cache.LastDecisionCode = string.IsNullOrWhiteSpace(decision.StrategyCode)
                ? decision.Action.ToString()
                : decision.StrategyCode;

            if (decision.Action == RouteAdjustmentAction.Hold)
            {
                if (decision.SuggestedHoldUntilUtc.HasValue)
                {
                    cache.HoldUntilUtc = decision.SuggestedHoldUntilUtc;
                }

                if (cache.PlanVersion <= expectedPlanVersion)
                {
                    cache.PlanVersion = expectedPlanVersion + 1;
                }

                if (!await TryPersistPathCacheCasWithFallbackAsync(db, key, cache, expectedPlanVersion, ct))
                {
                    _logger.LogWarning(
                        "VDA5050 - 持久化等待状态时发生并发冲突: RobotId={RobotId}, PlanVersion={PlanVersion}",
                        robot.RobotId, expectedPlanVersion);
                    return ApiResponse.Successful("路径状态并发更新，等待下次调度");
                }

                expectedPlanVersion = cache.PlanVersion;
                await ScheduleResumeDispatchAsync(robot, currentSubTask, key, cache, expectedPlanVersion, ct);

                _logger.LogInformation(
                    "VDA5050 - 全局协调器触发等待，暂停发送下一段: RobotId={RobotId}, Message={Message}, RouteMode={RouteMode}",
                    robot.RobotId, decision.Message, cache.RouteMode);
                return ApiResponse.Successful(string.IsNullOrWhiteSpace(decision.Message) ? "等待中" : decision.Message);
            }

            if (decision.Action == RouteAdjustmentAction.PatchTail ||
                decision.Action == RouteAdjustmentAction.ReplanTail)
            {
                if (decision.Patch == null)
                {
                    return ApiResponse.Failed("VDA5050 - 全局协调器返回补丁动作但补丁为空");
                }

                if (!_tailPatchApplier.TryApplyPatch(cache, decision.Patch, out var failureReason))
                {
                    _logger.LogWarning(
                        "VDA5050 - 尾段补丁应用失败: RobotId={RobotId}, PatchId={PatchId}, Reason={Reason}",
                        robot.RobotId, decision.Patch.PatchId, failureReason);
                    return ApiResponse.Successful($"尾段补丁应用失败，进入等待: {failureReason}");
                }

                cache.LastDecisionCode = $"{decision.Action}:{decision.Patch.StrategyCode}";
                if (!await TryPersistPathCacheCasWithFallbackAsync(db, key, cache, expectedPlanVersion, ct))
                {
                    _logger.LogWarning(
                        "VDA5050 - 持久化补丁结果时发生并发冲突: RobotId={RobotId}, ExpectedPlanVersion={PlanVersion}",
                        robot.RobotId, expectedPlanVersion);
                    return ApiResponse.Successful("路径状态并发更新，等待下次调度");
                }

                expectedPlanVersion = cache.PlanVersion;

                _logger.LogInformation(
                    "VDA5050 - 尾段补丁应用成功: RobotId={RobotId}, Action={Action}, PatchId={PatchId}, NewPlanVersion={PlanVersion}",
                    robot.RobotId, decision.Action, decision.Patch.PatchId, cache.PlanVersion);
            }
            else if (string.Equals(cache.RouteMode, RouteModeHold, StringComparison.Ordinal) ||
                     string.Equals(cache.RouteMode, RouteModeQueue, StringComparison.Ordinal) ||
                     string.Equals(cache.RouteMode, RouteModeOccupying, StringComparison.Ordinal) ||
                     string.Equals(cache.RouteMode, RouteModeDetouring, StringComparison.Ordinal) ||
                     string.Equals(cache.RouteMode, RouteModeReplanPending, StringComparison.Ordinal) ||
                     string.Equals(cache.RouteMode, RouteModeBlocked, StringComparison.Ordinal))
            {
                cache.RouteMode = RouteModeNormal;
                cache.HoldUntilUtc = null;
                cache.HoldNodeCode = null;
                cache.StablePassCount = 0;
                cache.ConsecutiveConflictFailCount = 0;
                cache.BlockedReason = null;
                cache.PlanVersion += 1;

                if (!await TryPersistPathCacheCasWithFallbackAsync(db, key, cache, expectedPlanVersion, ct))
                {
                    _logger.LogWarning(
                        "VDA5050 - 模式归一化时发生并发冲突: RobotId={RobotId}, ExpectedPlanVersion={PlanVersion}",
                        robot.RobotId, expectedPlanVersion);
                    return ApiResponse.Successful("路径状态并发更新，等待下次调度");
                }

                expectedPlanVersion = cache.PlanVersion;
            }
        }

        // 获取当前的两层索引
        var junctionIndex = cache.CurrentJunctionIndex;
        var resourceIndex = cache.CurrentResourceIndex;

        // 检查是否已完成所有段
        if (junctionIndex >= cache.JunctionSegments.Count)
        {
            return ApiResponse.Failed("VDA5050 - 已是最后一段，无下一段路径可发送");
        }

        // 获取当前路口段
        var currentJunctionGroup = cache.JunctionSegments[junctionIndex];

        // 检查资源段索引是否有效
        if (resourceIndex >= currentJunctionGroup.ResourceSegments.Count && !reExec)
        {
            // 当前路口段的资源段已全部发送，移动到下一个路口段
            junctionIndex++;
            resourceIndex = 0;

            if (junctionIndex >= cache.JunctionSegments.Count)
            {
                return ApiResponse.Failed("VDA5050 - 已是最后一段，无下一段路径可发送");
            }
            currentJunctionGroup = cache.JunctionSegments[junctionIndex];
        }

        // 检查网络动作（仅在非reExec模式下检查）
        if (!reExec)
        {
            var netActionCheck = await CheckAndExecuteNetActionsAsync(robot, currentSubTask, cache, junctionIndex, resourceIndex);
            if (!netActionCheck.CanContinue)
            {
                return ApiResponse.Failed($"网络动作拦截: {netActionCheck.Message}");
            }

            // 网络动作状态可能已推进路径版本，避免后续CAS使用过期版本号
            expectedPlanVersion = cache.PlanVersion;
        }


        // 获取下一段路径
        var nextSegment = currentJunctionGroup.ResourceSegments[resourceIndex].Segments;

        var segmentsToSend = new List<PathSegmentWithCode>(nextSegment);

        // 获取地图图结构（用于填充节点位置信息）
        var graph = await _agvPathService.GetOrBuildGraphAsync(cache.MapId);
        if (graph == null)
        {
            return ApiResponse.Failed("VDA5050 - 地图图结构加载失败");
        }

        // 锁定逻辑优化：
        // - 锁定单位：整个一级列表（路口切割后的段落）的所有路径和节点
        // - 发送一级列表的第一个二级列表时锁定整个一级列表
        // - 非第一个二级列表时跳过锁定（已锁定）
        if (resourceIndex == 0)
        {
            // 锁定整个一级列表的所有路径和节点
            var allJunctionSegments = currentJunctionGroup.ResourceSegments
                .SelectMany(r => r.Segments)
                .ToList();

            var lockCandidates = BuildSweptLockCandidates(allJunctionSegments, graph, robot);

            var lockResult = await _agvPathService.TryAcquireNextSegmentLockAsync(
                cache.MapCode,
                lockCandidates,
                robot.RobotId,
                30);

            if (!lockResult.Success)
            {
                cache.RouteMode = RouteModeHold;
                cache.HoldNodeCode = nextSegment.FirstOrDefault()?.FromNodeCode;
                cache.HoldUntilUtc = DateTime.Now.AddSeconds(2);
                cache.PlanVersion += 1;
                cache.LastDecisionCode = "LockAcquireFailedHold";
                await PublishLockConflictEventAsync(
                    robot.RobotId,
                    cache.MapCode,
                    nextSegment.FirstOrDefault()?.FromNodeCode,
                    nextSegment.FirstOrDefault()?.EdgeCode,
                    false,
                    lockResult.FailureReason,
                    ct);
                if (!await TryPersistPathCacheCasWithFallbackAsync(db, key, cache, expectedPlanVersion, ct))
                {
                    _logger.LogWarning(
                        "VDA5050 - 锁失败等待状态持久化冲突: RobotId={RobotId}, ExpectedPlanVersion={PlanVersion}",
                        robot.RobotId, expectedPlanVersion);
                    return ApiResponse.Successful("路径状态并发更新，等待下次调度");
                }

                expectedPlanVersion = cache.PlanVersion;
                await ScheduleResumeDispatchAsync(robot, currentSubTask, key, cache, expectedPlanVersion, ct);

                _logger.LogInformation("路口段锁定失败，等待下次尝试: RobotId={RobotId}, Reason={Reason}",
                    robot.RobotId, lockResult.FailureReason ?? "未知原因");
                return ApiResponse.Successful($"路口段锁定失败，进入等待: {lockResult.FailureReason ?? "未知原因"}");
            }

            // 检查是否存在逆向占用冲突
            if (lockResult.HasReverseConflict)
            {
                cache.RouteMode = RouteModeQueue;
                cache.HoldNodeCode = nextSegment.FirstOrDefault()?.FromNodeCode;
                cache.HoldUntilUtc = DateTime.Now.AddSeconds(3);
                cache.PlanVersion += 1;
                cache.LastDecisionCode = "ReverseConflictQueue";
                await PublishLockConflictEventAsync(
                    robot.RobotId,
                    cache.MapCode,
                    nextSegment.FirstOrDefault()?.FromNodeCode,
                    nextSegment.FirstOrDefault()?.EdgeCode,
                    true,
                    "获取下一路口锁时发生逆向边冲突",
                    ct);
                if (!await TryPersistPathCacheCasWithFallbackAsync(db, key, cache, expectedPlanVersion, ct))
                {
                    _logger.LogWarning(
                        "VDA5050 - 逆向冲突队列状态持久化冲突: RobotId={RobotId}, ExpectedPlanVersion={PlanVersion}",
                        robot.RobotId, expectedPlanVersion);
                    return ApiResponse.Successful("路径状态并发更新，等待下次调度");
                }

                expectedPlanVersion = cache.PlanVersion;
                await ScheduleResumeDispatchAsync(robot, currentSubTask, key, cache, expectedPlanVersion, ct);

                _logger.LogInformation("路口段存在逆向占用，暂停发送: RobotId={RobotId}", robot.RobotId);
                return ApiResponse.Successful("路口段存在逆向占用冲突，进入等待");
            }

            _logger.LogInformation("VDA5050 - 锁定整个路口段成功，机器人: {RobotId}, 路口段: {JunctionIndex}, 锁定节点: {NodeCount}, 锁定边: {EdgeCount}",
                robot.RobotId, junctionIndex, lockResult.LockedNodeCodes.Count, lockResult.LockedEdgeCodes.Count);
        }
        else
        {
            // resourceIndex > 0：当前一级列表已锁定，跳过锁定请求
            _logger.LogDebug("VDA5050 - 当前路口段已锁定，跳过锁定请求，机器人: {RobotId}, 路口段: {JunctionIndex}, 资源段: {ResourceIndex}",
                robot.RobotId, junctionIndex, resourceIndex);
        }

        // 重新查询完整的 SubTask 信息（含导航属性）。
        // 兼容不落库的临时子任务：查不到时回退使用传入子任务继续下发。
        var fullSubTask = await _subTaskRepository.GetByIdWithDetailsAsync(currentSubTask.SubTaskId, ct);
        var canPersistSubTaskState = fullSubTask != null;
        if (fullSubTask == null)
        {
            fullSubTask = currentSubTask;
            _logger.LogDebug(
                "VDA5050 - 子任务未落库，使用内存子任务继续下发。RobotId={RobotId}, TaskId={TaskId}, SubTaskId={SubTaskId}",
                robot.RobotId,
                currentSubTask.TaskId,
                currentSubTask.SubTaskId);
        }

        var lastSeqId = cache.LastSentSequenceId;

        // if (IsInPlaceSegments(segmentsToSend))
        // {
        //     // 原地路径：不发送 Order，改为发送即时动作
        //     var instantAction = await BuildInstantActionFromInPlaceSegmentsAsync(robot, fullSubTask, segmentsToSend, ct);
        //     if (instantAction != null)
        //     {
        //         await _mqttClientService.PublishInstantActionsAsync(
        //             robot.ProtocolName,
        //             robot.ProtocolVersion,
        //             robot.RobotManufacturer,
        //             robot.RobotSerialNumber,
        //             instantAction,
        //             ct: ct);
        //
        //         _logger.LogInformation(
        //             "VDA5050 - 原地路径已改为即时动作发送，机器人: {SerialNumber}, 动作数: {ActionCount}",
        //             robot.RobotSerialNumber,
        //             instantAction.Actions.Count);
        //     }
        //     else
        //     {
        //         _logger.LogWarning(
        //             "VDA5050 - 原地路径未解析出有效动作，跳过即时动作发送，机器人: {SerialNumber}",
        //             robot.RobotSerialNumber);
        //     }
        // }
        // else
        // {
            // 构建订单并填充下一段路径
            // @author zzy
            // 2026-02-25 更新：分段发送时 sequenceId 延续已发送的值，prefix 段复用原始 sequenceId
            var order = BuildVdaOrder(robot, fullSubTask);
            var hasPrefixSegment = (junctionIndex > 0 || resourceIndex > 0);
            // 有 prefix 段时，从 LastSentSequenceId - 2 开始（prefix 的 FromNode 复用原始编号）
            // 无 prefix 段（首段）时，从 0 开始
            var startSeqId = hasPrefixSegment ? cache.LastSentSequenceId : 0;
            PathSegmentWithCode? temporaryNextSegment = null;
            if (resourceIndex + 1 < currentJunctionGroup.ResourceSegments.Count)
            {
                temporaryNextSegment = currentJunctionGroup.ResourceSegments[resourceIndex + 1].Segments.FirstOrDefault();
            }
            else if (junctionIndex + 1 < cache.JunctionSegments.Count)
            {
                temporaryNextSegment = cache.JunctionSegments[junctionIndex + 1]
                    .ResourceSegments
                    .FirstOrDefault()?
                    .Segments
                    .FirstOrDefault();
            }

            // 预告下一节点会额外增加一个 Released=false 节点，若超过上限则跳过预告。
            var maxDispatchNodeCount = GetMaxDispatchNodeCount();
            if (temporaryNextSegment != null && segmentsToSend.Count + 2 > maxDispatchNodeCount)
            {
                temporaryNextSegment = null;
            }

            await FillOrderWithSegmentsAsync(
                order,
                segmentsToSend,
                graph,
                robot,
                fullSubTask,
                startSeqId,
                ct,
                temporaryNextSegment);

            // 仅以 Released=true 的节点/边计算“已发送序列号”，避免预告段（Released=false）写入已发送队列。
            var lastReleasedNodeSeq = order.Nodes
                .Where(n => n.Released)
                .Select(n => n.SequenceId)
                .DefaultIfEmpty(startSeqId)
                .Max();
            var lastReleasedEdgeSeq = order.Edges
                .Where(e => e.Released)
                .Select(e => e.SequenceId)
                .DefaultIfEmpty(startSeqId)
                .Max();
            lastSeqId = Math.Max(lastReleasedNodeSeq, lastReleasedEdgeSeq);

            // 发送订单
            await _mqttClientService.PublishOrderAsync(
                robot.ProtocolName,
                robot.ProtocolVersion,
                robot.RobotManufacturer,
                robot.RobotSerialNumber,
                order,
                ct: ct);
        // }

        // 更新缓存：标记当前段为已发送，更新索引，记录最大 sequenceId
        currentJunctionGroup.ResourceSegments[resourceIndex].IsSent = true;
        cache.LastSentSequenceId = lastSeqId;

        if (string.Equals(cache.RouteMode, RouteModeRejoining, StringComparison.Ordinal))
        {
            cache.RouteMode = RouteModeNormal;
            cache.ActivePatchId = null;
            cache.HoldUntilUtc = null;
            cache.HoldNodeCode = null;
            cache.StablePassCount = 0;
            cache.ConsecutiveConflictFailCount = 0;
            cache.BlockedReason = null;
        }

        if (!reExec)
        {
            // 移动到下一个资源段
            resourceIndex++;
            if (resourceIndex >= currentJunctionGroup.ResourceSegments.Count)
            {
                // 当前路口段完成，移动到下一个路口段
                junctionIndex++;
                resourceIndex = 0;
            }
        }

        cache.CurrentJunctionIndex = junctionIndex;
        cache.CurrentResourceIndex = resourceIndex;

        if (cache.PlanVersion <= expectedPlanVersion)
        {
            cache.PlanVersion = expectedPlanVersion + 1;
        }

        if (!await TryPersistPathCacheCasWithFallbackAsync(db, key, cache, expectedPlanVersion, ct))
        {
            _logger.LogError(
                "路径段索引更新发生并发冲突: RobotId={RobotId}, ExpectedPlanVersion={PlanVersion}",
                robot.RobotId, expectedPlanVersion);
        }
        else
        {
            expectedPlanVersion = cache.PlanVersion;
        }
        // 递增执行次数
        fullSubTask.ExecutionCount++;

        _logger.LogInformation("VDA5050 - 子任务: {SubTaskId}, 执行次数递增为: {ExecutionCount}, 路口段: {JunctionIndex}, 资源段: {ResourceIndex}",
            fullSubTask.SubTaskId, fullSubTask.ExecutionCount, junctionIndex, resourceIndex);
        // 显式更新子任务实体（解决引用同步问题）
        fullSubTask.Start();
        if (canPersistSubTaskState)
        {
            // fullSubTask 由当前 DbContext 查询得到，已处于跟踪状态。
            // 仅提交变更，避免同键实体重复 Attach 导致跟踪冲突。
            await _subTaskRepository.SaveChangesAsync(ct);
        }
        else
        {
            _logger.LogDebug(
                "VDA5050 - 子任务未落库，跳过子任务状态持久化。RobotId={RobotId}, TaskId={TaskId}, SubTaskId={SubTaskId}",
                robot.RobotId,
                fullSubTask.TaskId,
                fullSubTask.SubTaskId);
        }

        // 持久化递增后的 HeaderId
        await _robotRepository.UpdateAsync(robot, ct);
        await _robotRepository.SaveChangesAsync(ct);

        _logger.LogInformation("VDA5050 - 段路径发送成功，机器人: {SerialNumber}, 下一路口段: {JunctionIndex}, 资源段: {ResourceIndex}",
            robot.RobotSerialNumber, cache.CurrentJunctionIndex, cache.CurrentResourceIndex);

        return ApiResponse.Successful();
    }

    /// <summary>
    /// 根据制造商与序列号定位机器人并发送下一段路径。
    /// </summary>
    public async Task<ApiResponse> SendNextSegmentAsync(string robotManufacturer, string robotSerialNumber, CancellationToken ct = default, bool reExec = false)
    {
        try
        {
            var robot = await _robotRepository.GetByManufacturerAndSerialNumberAsync(robotManufacturer, robotSerialNumber, ct);
            if (robot == null)
                throw new Exception($"制造商:{robotManufacturer},序列号:{robotSerialNumber} 的机器人不存在");

            // 尝试获取分布式锁，防止并发重复发送
            var lockKey = $"send_segment_lock:{robot.RobotId}";
            var lockAcquired = await _redis.GetDatabase().StringSetAsync(
                lockKey, "1", TimeSpan.FromSeconds(10), When.NotExists);

            if (!lockAcquired)
            {
                _logger.LogInformation("[段发送] 其他进程正在发送路径段，跳过: RobotId={RobotId}", robot.RobotId);
                return ApiResponse.Failed("路径段发送正在进行中");
            }

            try
            {
                var tasks = await _taskRepository.GetByRobotIdAsync(robot.RobotId, ct);
                // 优先选择“存在执行中子任务”的执行中主任务，避免多InProgress主任务时选错上下文。
                var inProgressTaskWithRunningSubTask = tasks
                    .Where(t => t.Status == Rcs.Domain.Entities.TaskStatus.InProgress)
                    .Select(t => new
                    {
                        Task = t,
                        SubTask = t.SubTasks
                            .OrderBy(st => st.Sequence)
                            .FirstOrDefault(st => st.Status == Rcs.Domain.Entities.TaskStatus.InProgress)
                    })
                    .FirstOrDefault(x => x.SubTask != null);

                if (inProgressTaskWithRunningSubTask != null)
                {
                    _logger.LogDebug(
                        "[段发送] 选中执行中子任务上下文: RobotId={RobotId}, TaskId={TaskId}, SubTaskId={SubTaskId}",
                        robot.RobotId,
                        inProgressTaskWithRunningSubTask.Task.TaskId,
                        inProgressTaskWithRunningSubTask.SubTask!.SubTaskId);

                    return await SendNextSegmentInternalAsync(
                        robot,
                        inProgressTaskWithRunningSubTask.SubTask!,
                        ct,
                        reExec);
                }

                // 回退：如果没有执行中子任务，则沿用原逻辑从执行中主任务里找待执行子任务。
                var currInProgressTask = tasks.FirstOrDefault(st => st.Status == Rcs.Domain.Entities.TaskStatus.InProgress);
                if (currInProgressTask != null)
                {
                    var currSubTask = currInProgressTask.SubTasks.OrderBy(st => st.Sequence).FirstOrDefault(st => st.Status == Rcs.Domain.Entities.TaskStatus.Pending
                            || st.Status == Rcs.Domain.Entities.TaskStatus.InProgress);
                    if (currSubTask == null)
                        throw new Exception($"任务号 {currInProgressTask.TaskCode} 不存在子任务");

                    return await SendNextSegmentInternalAsync(robot, currSubTask, ct, reExec);
                }

                var currPendingTask = tasks.FirstOrDefault(st => st.Status == Rcs.Domain.Entities.TaskStatus.Pending);
                if (currPendingTask != null)
                {
                    var currSubTask = currPendingTask.SubTasks.OrderBy(st => st.Sequence).FirstOrDefault(st => st.Status == Rcs.Domain.Entities.TaskStatus.Pending
                        || st.Status == Rcs.Domain.Entities.TaskStatus.InProgress);
                    if (currSubTask == null)
                        throw new Exception($"任务号 {currPendingTask.TaskCode} 不存在子任务");

                    return await SendNextSegmentInternalAsync(robot, currSubTask, ct, reExec);
                }

                throw new Exception($"机器人 {robot.RobotCode} 不存在执行中或待执行的任务");
            }
            finally
            {
                // 释放锁
                await _redis.GetDatabase().KeyDeleteAsync(lockKey);
            }
        }
        catch (Exception e)
        {
            return ApiResponse.Failed(e.Message);
        }
    }
    /// <summary>
    /// 删除指定任务的VDA路径缓存数据
    /// </summary>
    /// <param name="robotId">机器人ID</param>
    /// <param name="orderId">订单ID（任务编码）</param>
    private async Task ClearVdaPathCacheAsync(Guid robotId, string orderId)
    {
        try
        {
            var db = _redis.GetDatabase();

            // 尝试删除两种可能的Key格式
            // 格式1: {prefix}{robotId}:{taskId} （在SendNextSegmentAsync中使用）
            var key1 = $"{_settings.Redis.KeyPrefixes.VdaPath}:{robotId}:{orderId}";
            var deleted1 = await db.KeyDeleteAsync(key1);
            var deleted1Plan = await db.KeyDeleteAsync(BuildPathPlanVersionKey(key1));

            // 格式2: {prefix}{robotId}:{taskId}:{subTaskId} （在SaveSegmentedPathAsync中使用）
            // 使用KeyDeleteByPattern删除匹配模式的所有Key
            var pattern = $"{_settings.Redis.KeyPrefixes.VdaPath}:{robotId}:{orderId}:*";
            var deleted2 = await KeyDeleteByPatternAsync(pattern);

            // 将bool转换为数量进行统计
            var count1 = deleted1 ? 1 : 0;
            var count1Plan = deleted1Plan ? 1 : 0;
            var totalDeleted = count1 + count1Plan + deleted2;
            _logger.LogInformation("VDA5050 - 删除VDA路径缓存，机器人: {RobotId}, 订单: {OrderId}, 删除数量: {Count}",
                robotId, orderId, totalDeleted);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "VDA5050 - 删除VDA路径缓存失败，机器人: {RobotId}, 订单: {OrderId}",
                robotId, orderId);
        }
    }

    /// <summary>
    /// 删除指定机器人所有任务的VDA路径缓存数据
    /// </summary>
    /// <param name="robotId">机器人ID</param>
    public async Task ClearAllVdaPathCacheAsync(Guid robotId)
    {
        try
        {
            var pattern = $"{_settings.Redis.KeyPrefixes.VdaPath}:{robotId}:*";
            var deletedCount = await KeyDeleteByPatternAsync(pattern);

            _logger.LogInformation("VDA5050 - 删除机器人所有VDA路径缓存，机器人: {RobotId}, 删除数量: {Count}",
                robotId, deletedCount);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "VDA5050 - 删除机器人所有VDA路径缓存失败，机器人: {RobotId}", robotId);
        }
    }

    /// <summary>
    /// 按当前等待信息调度一次延迟恢复发送。
    /// </summary>
    private async Task ScheduleResumeDispatchAsync(
        Robot robot,
        RobotSubTask currentSubTask,
        string pathCacheKey,
        VdaSegmentedPathCache cache,
        long expectedPlanVersion,
        CancellationToken ct)
    {
        try
        {
            var resumeAtUtc = cache.HoldUntilUtc ?? DateTime.Now.AddSeconds(1);
            await _globalNavigationResumeScheduler.ScheduleResumeAsync(new HoldResumeRequest
            {
                RobotId = robot.RobotId,
                RobotManufacturer = robot.RobotManufacturer,
                RobotSerialNumber = robot.RobotSerialNumber,
                TaskId = currentSubTask.TaskId,
                SubTaskId = currentSubTask.SubTaskId,
                PathCacheKey = pathCacheKey,
                ExpectedPlanVersion = expectedPlanVersion,
                HoldNodeCode = cache.HoldNodeCode,
                ResumeAtUtc = resumeAtUtc
            }, ct);
        }
        catch (Exception ex)
        {
            _logger.LogWarning(
                ex,
                "VDA5050 - 调度等待恢复触发失败: RobotId={RobotId}, TaskId={TaskId}, SubTaskId={SubTaskId}",
                robot.RobotId, currentSubTask.TaskId, currentSubTask.SubTaskId);
        }
    }

    /// <summary>
    /// 发布锁冲突事件给全局导航协调器。
    /// </summary>
    private async Task PublishLockConflictEventAsync(
        Guid robotId,
        string mapCode,
        string? nodeCode,
        string? edgeCode,
        bool hasReverseConflict,
        string? failureReason,
        CancellationToken ct)
    {
        try
        {
            await _globalNavigationCoordinator.PublishLockConflictEventAsync(new LockConflictNavigationEvent
            {
                RobotId = robotId,
                MapCode = mapCode,
                NodeCode = nodeCode,
                EdgeCode = edgeCode,
                HasReverseConflict = hasReverseConflict,
                FailureReason = failureReason,
                OccurredAtUtc = DateTime.Now
            }, ct);
        }
        catch (Exception ex)
        {
            _logger.LogDebug(
                ex,
                "VDA5050 - 发布锁冲突事件失败: RobotId={RobotId}, Node={NodeCode}, Edge={EdgeCode}",
                robotId,
                nodeCode,
                edgeCode);
        }
    }

    /// <summary>
    /// 刷新路径CAS动态配置。
    /// </summary>
    private void RefreshPathCasSettings()
    {
        var current = _settingsMonitor.CurrentValue;
        ApplyPathCasSettings(current);
    }

    /// <summary>
    /// 应用路径CAS配置并更新派生时间窗口参数。
    /// </summary>
    private void ApplyPathCasSettings(AppSettings appSettings)
    {
        _pathCasSettings = appSettings.GlobalNavigation?.PathCas ?? new GlobalPathCasSettings();
        _pathCasMetricsInterval = TimeSpan.FromSeconds(Math.Max(10, _pathCasSettings.MetricsIntervalSeconds));
        _pathCasWindowDuration = TimeSpan.FromSeconds(Math.Max(5, _pathCasSettings.WindowDurationSeconds));
    }

    /// <summary>
    /// 构建路径版本号Key。
    /// </summary>
    private static string BuildPathPlanVersionKey(string pathKey) => $"{pathKey}:planVersion";

    /// <summary>
    /// 确保路径版本号Key存在（仅首次写入）。
    /// </summary>
    private async Task EnsurePathPlanVersionKeyAsync(IDatabase db, string pathKey, long planVersion)
    {
        await db.StringSetAsync(BuildPathPlanVersionKey(pathKey), planVersion.ToString(), when: When.NotExists);
    }

    /// <summary>
    /// 按预期版本执行一次路径缓存CAS写入。
    /// </summary>
    private async Task<bool> TryPersistPathCacheCasAsync(
        IDatabase db,
        string pathKey,
        VdaSegmentedPathCache cache,
        long expectedPlanVersion,
        CancellationToken ct = default)
    {
        System.Threading.Interlocked.Increment(ref _pathCasDirectAttemptCount);
        RegisterPathCasWindowAttempt();
        var payload = JsonSerializer.Serialize(cache);
        var planVersionKey = BuildPathPlanVersionKey(pathKey);

        for (var attempt = 0; attempt < 2; attempt++)
        {
            ct.ThrowIfCancellationRequested();
            var tx = db.CreateTransaction();
            tx.AddCondition(Condition.StringEqual(planVersionKey, expectedPlanVersion.ToString()));
            _ = tx.StringSetAsync(pathKey, payload);
            _ = tx.StringSetAsync(planVersionKey, cache.PlanVersion.ToString());

            if (await tx.ExecuteAsync())
            {
                System.Threading.Interlocked.Increment(ref _pathCasDirectSuccessCount);
                MaybeLogPathCasMetrics();
                return true;
            }

            if (attempt == 0)
            {
                await db.StringSetAsync(planVersionKey, expectedPlanVersion.ToString(), when: When.NotExists);
            }
        }

        System.Threading.Interlocked.Increment(ref _pathCasConflictCount);
        RegisterPathCasWindowConflict();
        MaybeLogPathCasMetrics();
        return false;
    }

    /// <summary>
    /// 执行带回退机制的路径缓存CAS写入。
    /// </summary>
    private async Task<bool> TryPersistPathCacheCasWithFallbackAsync(
        IDatabase db,
        string pathKey,
        VdaSegmentedPathCache cache,
        long expectedPlanVersion,
        CancellationToken ct = default)
    {
        await ApplyPathCasBackpressureIfNeededAsync(ct);

        if (await TryPersistPathCacheCasAsync(db, pathKey, cache, expectedPlanVersion, ct))
        {
            return true;
        }

        System.Threading.Interlocked.Increment(ref _pathCasFallbackAttemptCount);
        var planVersionValue = await db.StringGetAsync(BuildPathPlanVersionKey(pathKey));
        if (planVersionValue.IsNullOrEmpty || !long.TryParse(planVersionValue.ToString(), out var latestVersion))
        {
            System.Threading.Interlocked.Increment(ref _pathCasFailureCount);
            RegisterPathCasWindowFailure();
            MaybeLogPathCasMetrics();
            return false;
        }

        if (cache.PlanVersion <= latestVersion)
        {
            cache.PlanVersion = latestVersion + 1;
        }

        var fallbackSuccess = await TryPersistPathCacheCasAsync(db, pathKey, cache, latestVersion, ct);
        if (fallbackSuccess)
        {
            System.Threading.Interlocked.Increment(ref _pathCasFallbackSuccessCount);
        }
        else
        {
            System.Threading.Interlocked.Increment(ref _pathCasFailureCount);
            RegisterPathCasWindowFailure();
        }

        MaybeLogPathCasMetrics();
        return fallbackSuccess;
    }

    /// <summary>
    /// 记录CAS窗口尝试计数。
    /// </summary>
    private void RegisterPathCasWindowAttempt()
    {
        lock (_pathCasWindowLock)
        {
            EnsurePathCasWindowUnlocked();
            _pathCasWindowAttemptCount++;
        }
    }

    /// <summary>
    /// 记录CAS窗口冲突计数。
    /// </summary>
    private void RegisterPathCasWindowConflict()
    {
        lock (_pathCasWindowLock)
        {
            EnsurePathCasWindowUnlocked();
            _pathCasWindowConflictCount++;
        }
    }

    /// <summary>
    /// 记录CAS窗口失败计数。
    /// </summary>
    private void RegisterPathCasWindowFailure()
    {
        lock (_pathCasWindowLock)
        {
            EnsurePathCasWindowUnlocked();
            _pathCasWindowFailureCount++;
        }
    }

    /// <summary>
    /// 在高冲突场景下应用随机退避，降低CAS冲突放大。
    /// </summary>
    private async Task ApplyPathCasBackpressureIfNeededAsync(CancellationToken ct)
    {
        RefreshPathCasSettings();

        if (!_pathCasSettings.EnableHighConflictBackoff)
        {
            return;
        }

        long attempts;
        long conflicts;

        lock (_pathCasWindowLock)
        {
            EnsurePathCasWindowUnlocked();
            attempts = _pathCasWindowAttemptCount;
            conflicts = _pathCasWindowConflictCount;
        }

        var minAttempts = Math.Max(1, _pathCasSettings.HighConflictMinAttempts);
        if (attempts < minAttempts)
        {
            return;
        }

        var conflictRatioThreshold = Math.Clamp(_pathCasSettings.HighConflictRatioThreshold, 0.01, 1.0);
        var conflictRatio = attempts == 0 ? 0 : (double)conflicts / attempts;
        if (conflictRatio < conflictRatioThreshold)
        {
            return;
        }

        var delayMinMs = Math.Max(1, _pathCasSettings.BackoffMinMs);
        var delayMaxMs = Math.Max(delayMinMs, _pathCasSettings.BackoffMaxMs);
        var delayMs = Random.Shared.Next(delayMinMs, delayMaxMs + 1);
        _logger.LogDebug(
            "[路径CAS] 高冲突退避: 尝试={Attempts}, 冲突={Conflicts}, 比例={Ratio:P2}, 延迟毫秒={DelayMs}",
            attempts, conflicts, conflictRatio, delayMs);
        await Task.Delay(delayMs, ct);
    }

    /// <summary>
    /// 若当前统计窗口过期则重置窗口计数。
    /// </summary>
    private void EnsurePathCasWindowUnlocked()
    {
        var now = DateTime.Now;
        if (now - _pathCasWindowStartedUtc < _pathCasWindowDuration)
        {
            return;
        }

        _pathCasWindowStartedUtc = now;
        _pathCasWindowAttemptCount = 0;
        _pathCasWindowConflictCount = 0;
        _pathCasWindowFailureCount = 0;
    }

    /// <summary>
    /// 按间隔输出路径CAS指标日志。
    /// </summary>
    private void MaybeLogPathCasMetrics()
    {
        RefreshPathCasSettings();
        var now = DateTime.Now;
        if (now - _lastPathCasMetricsLogUtc < _pathCasMetricsInterval)
        {
            return;
        }

        _lastPathCasMetricsLogUtc = now;
        var directAttempt = System.Threading.Interlocked.Read(ref _pathCasDirectAttemptCount);
        var directSuccess = System.Threading.Interlocked.Read(ref _pathCasDirectSuccessCount);
        var conflict = System.Threading.Interlocked.Read(ref _pathCasConflictCount);
        var fallbackAttempt = System.Threading.Interlocked.Read(ref _pathCasFallbackAttemptCount);
        var fallbackSuccess = System.Threading.Interlocked.Read(ref _pathCasFallbackSuccessCount);
        var failure = System.Threading.Interlocked.Read(ref _pathCasFailureCount);
        var conflictRatio = directAttempt == 0 ? 0 : (double)conflict / directAttempt;

        var minAttempts = Math.Max(1, _pathCasSettings.HighConflictMinAttempts);
        var conflictRatioThreshold = Math.Clamp(_pathCasSettings.HighConflictRatioThreshold, 0.01, 1.0);
        var logLevelIsWarning = directAttempt >= minAttempts &&
                                conflictRatio >= conflictRatioThreshold;

        if (logLevelIsWarning)
        {
            _logger.LogWarning(
                "[路径CAS] 指标告警: 直接尝试={DirectAttempt}, 直接成功={DirectSuccess}, 冲突={Conflict}, 冲突比={ConflictRatio:P2}, 回退尝试={FallbackAttempt}, 回退成功={FallbackSuccess}, 失败={Failure}",
                directAttempt, directSuccess, conflict, conflictRatio, fallbackAttempt, fallbackSuccess, failure);
            return;
        }

        _logger.LogInformation(
            "[路径CAS] 指标: 直接尝试={DirectAttempt}, 直接成功={DirectSuccess}, 冲突={Conflict}, 冲突比={ConflictRatio:P2}, 回退尝试={FallbackAttempt}, 回退成功={FallbackSuccess}, 失败={Failure}",
            directAttempt, directSuccess, conflict, conflictRatio, fallbackAttempt, fallbackSuccess, failure);
    }

    /// <summary>
    /// 根据模式删除Redis Key
    /// </summary>
    /// <param name="pattern">Key匹配模式</param>
    /// <returns>删除的Key数量</returns>
    private async Task<int> KeyDeleteByPatternAsync(string pattern)
    {
        var server = _redis.GetServer(_redis.GetEndPoints().First());
        var keys = server.Keys(pattern: pattern).ToArray();

        if (keys.Length == 0)
        {
            return 0;
        }

        var db = _redis.GetDatabase();
        return (int)await db.KeyDeleteAsync(keys);
    }

    /// <summary>
    /// 检查并执行网络动作
    /// 在发送下一段路径之前调用，检查的是**上一个已发送段**的终点网络动作
    /// 核心逻辑：机器人到达当前段终点时，检查该终点是否有网络动作需要执行
    /// @author zzy
    /// 2026-02-06 创建
    /// 2026-02-07 修复：检查上一个已发送段的终点网络动作，而非即将发送段
    /// </summary>
    private async Task<SegmentNetActionCheckResult> CheckAndExecuteNetActionsAsync(
        Robot robot,
        RobotSubTask subTask,
        VdaSegmentedPathCache cache,
        int junctionIndex,
        int resourceIndex)
    {
        var result = new SegmentNetActionCheckResult
        {
            CanContinue = true
        };

        // 获取上一个已发送段的索引（机器人当前所在位置）
        var (prevJunctionIndex, prevResourceIndex) = GetPreviousSentSegmentIndex(cache, junctionIndex, resourceIndex);

        // 如果没有上一个已发送段（首次发送），直接返回可继续
        if (prevJunctionIndex < 0 || prevResourceIndex < 0)
        {
            return result;
        }

        // 检查索引有效性
        if (prevJunctionIndex >= cache.JunctionSegments.Count)
        {
            return result;
        }

        var junctionSegment = cache.JunctionSegments[prevJunctionIndex];
        if (prevResourceIndex >= junctionSegment.ResourceSegments.Count)
        {
            return result;
        }

        var resourceSegment = junctionSegment.ResourceSegments[prevResourceIndex];

        // 获取该段的终点网络动作ID列表（仅Apply类型）
        var netActionIds = resourceSegment.GetEndNodeNetActionIds();

        if (netActionIds.Count == 0)
        {
            // 没有网络动作，可以正常发送
            return result;
        }

        _logger.LogInformation("[网络动作检查] 发现{Count}个终点网络动作: RobotId={RobotId}, PrevJunctionIndex={PrevJunctionIndex}, PrevResourceIndex={PrevResourceIndex}",
            netActionIds.Count, robot.RobotId, prevJunctionIndex, prevResourceIndex);

        // 检查该段是否已经执行过网络动作
        if (resourceSegment.IsEndNodeNetActionExecuted)
        {
            _logger.LogDebug("[网络动作检查] 该段网络动作已执行过，继续发送: RobotId={RobotId}", robot.RobotId);
            return result;
        }

        // 检查是否有正在进行的网络动作
        var hasInProgress = await _netActionExecutionService.HasInProgressNetActionAsync(
            robot.RobotId, cache.TaskId, subTask.SubTaskId, prevJunctionIndex, prevResourceIndex);

        if (hasInProgress)
        {
            result.CanContinue = false;
            result.Message = "网络动作正在执行中";
            return result;
        }

        // 检查是否有等待异步响应的网络动作
        var hasWaitingAsync = await _netActionExecutionService.HasWaitingAsyncResponseAsync(
            robot.RobotId, cache.TaskId, subTask.SubTaskId);

        if (hasWaitingAsync)
        {
            result.CanContinue = false;
            result.IsWaitingAsync = true;
            result.Message = "等待异步响应中";
            return result;
        }

        // 获取最后一段的终点节点信息
        var lastSegment = resourceSegment.Segments.LastOrDefault();
        if (lastSegment == null)
        {
            return result;
        }

        // 批量执行网络动作
        var executeRequests = new List<NetActionExecuteRequest>();
        var resolvedTaskCode = string.IsNullOrWhiteSpace(cache.TaskCode)
            ? cache.TaskId.ToString()
            : cache.TaskCode;
        foreach (var netActionId in netActionIds)
        {
            var contextId = $"{robot.RobotId}:{cache.TaskId}:{subTask.SubTaskId}:{prevJunctionIndex}:{prevResourceIndex}:{netActionId}:{Guid.NewGuid():N}";

            executeRequests.Add(new NetActionExecuteRequest
            {
                NetActionId = netActionId,
                ContextId = contextId,
                RobotId = robot.RobotId,
                RobotCode = robot.RobotCode,
                TaskId = cache.TaskId,
                TaskCode = resolvedTaskCode,
                SubTaskId = subTask.SubTaskId,
                NodeCode = lastSegment.ToNodeCode,
                NodeId = lastSegment.ToNodeId,
                EdgeId = lastSegment.EdgeId,
                EdgeCode = lastSegment.EdgeCode,
                JunctionIndex = prevJunctionIndex,
                ResourceIndex = prevResourceIndex
            });

            // 保存上下文ID到缓存
            resourceSegment.EndNodeNetActionContextIds.Add(contextId);
        }

        // 更新缓存状态
        var cacheKey = $"{_settings.Redis.KeyPrefixes.VdaPath}:{robot.RobotId}:{subTask.TaskId}:{subTask.SubTaskId}";
        var db = _redis.GetDatabase();
        var expectedPlanVersion = cache.PlanVersion;
        await EnsurePathPlanVersionKeyAsync(db, cacheKey, expectedPlanVersion);

        cache.NetActionStatus = NetActionExecutionStatus.Executing;
        cache.ActiveNetActionContextId = resourceSegment.EndNodeNetActionContextIds.FirstOrDefault();
        if (cache.PlanVersion <= expectedPlanVersion)
        {
            cache.PlanVersion = expectedPlanVersion + 1;
        }

        if (!await TryPersistPathCacheCasWithFallbackAsync(db, cacheKey, cache, expectedPlanVersion))
        {
            result.CanContinue = false;
            result.Message = "网络动作状态更新冲突，等待下次调度";
            return result;
        }

        expectedPlanVersion = cache.PlanVersion;

        // 执行网络动作
        var executeResult = await _netActionExecutionService.ExecuteNetActionsAsync(executeRequests);

        if (!executeResult.Success)
        {
            result.CanContinue = false;
            result.Message = $"网络动作执行失败: {executeResult.Message}";

            // 更新缓存状态为失败
            cache.NetActionStatus = NetActionExecutionStatus.Failed;
            if (cache.PlanVersion <= expectedPlanVersion)
            {
                cache.PlanVersion = expectedPlanVersion + 1;
            }

            if (!await TryPersistPathCacheCasWithFallbackAsync(db, cacheKey, cache, expectedPlanVersion))
            {
                _logger.LogWarning("[网络动作检查] 失败状态写入冲突: RobotId={RobotId}", robot.RobotId);
            }
            else
            {
                expectedPlanVersion = cache.PlanVersion;
            }

            return result;
        }

        // 如果是异步等待，设置等待状态
        if (executeResult.IsAsyncWaiting)
        {
            result.CanContinue = false;
            result.IsWaitingAsync = true;
            result.ContextId = executeResult.ContextId;
            result.Message = "网络动作请求已发送，等待异步回调";

            // 更新缓存状态为等待异步响应
            cache.NetActionStatus = NetActionExecutionStatus.WaitingAsyncResponse;
            if (cache.PlanVersion <= expectedPlanVersion)
            {
                cache.PlanVersion = expectedPlanVersion + 1;
            }

            if (!await TryPersistPathCacheCasWithFallbackAsync(db, cacheKey, cache, expectedPlanVersion))
            {
                _logger.LogWarning("[网络动作检查] 等待异步状态写入冲突: RobotId={RobotId}", robot.RobotId);
            }
            else
            {
                expectedPlanVersion = cache.PlanVersion;
            }

            return result;
        }

        // 网络动作执行成功，标记为已执行
        resourceSegment.IsEndNodeNetActionExecuted = true;

        // 更新缓存状态为成功
        cache.NetActionStatus = NetActionExecutionStatus.Success;
        cache.ActiveNetActionContextId = null;
        if (cache.PlanVersion <= expectedPlanVersion)
        {
            cache.PlanVersion = expectedPlanVersion + 1;
        }

        if (!await TryPersistPathCacheCasWithFallbackAsync(db, cacheKey, cache, expectedPlanVersion))
        {
            _logger.LogWarning("[网络动作检查] 成功状态写入冲突: RobotId={RobotId}", robot.RobotId);
        }
        else
        {
            expectedPlanVersion = cache.PlanVersion;
        }

        _logger.LogInformation("[网络动作检查] 网络动作执行成功，继续发送路径段: RobotId={RobotId}", robot.RobotId);

        return result;
    }

    /// <summary>
    /// 获取上一个已发送段的索引
    /// 用于确定机器人当前所在位置（已到达的段终点）
    /// @author zzy
    /// 2026-02-07
    /// </summary>
    /// <param name="cache">路径缓存</param>
    /// <param name="currentJunctionIndex">当前路口段索引</param>
    /// <param name="currentResourceIndex">当前资源段索引</param>
    /// <returns>上一个已发送段的索引，如果没有则返回(-1, -1)</returns>
    private static (int JunctionIndex, int ResourceIndex) GetPreviousSentSegmentIndex(
        VdaSegmentedPathCache cache,
        int currentJunctionIndex,
        int currentResourceIndex)
    {
        // 如果当前资源段索引大于0，上一段在同一路口段内
        if (currentResourceIndex > 0)
        {
            return (currentJunctionIndex, currentResourceIndex - 1);
        }

        // 如果当前资源段索引为0，需要查找上一个路口段的最后一个资源段
        if (currentJunctionIndex > 0)
        {
            var prevJunctionIndex = currentJunctionIndex - 1;
            var prevJunction = cache.JunctionSegments[prevJunctionIndex];
            var prevResourceIndex = prevJunction.ResourceSegments.Count - 1;
            return (prevJunctionIndex, prevResourceIndex);
        }

        // 没有上一段（首次发送）
        return (-1, -1);
    }

    /// <summary>
    /// 判断指定机器人当前是否已在最后一段路径上（所有段已发送完毕）
    /// 通过Redis轻量读取VDA路径缓存，检查两层索引是否已越界
    /// @author zzy
    /// </summary>
    /// <param name="robotManufacturer">机器人制造商</param>
    /// <param name="robotSerialNumber">机器人序列号</param>
    /// <param name="ct">取消令牌</param>
    /// <returns>true表示所有段已发送完毕，false表示还有后续段或无法判断</returns>
    public async Task<bool> IsAllSegmentsSentAsync(string robotManufacturer, string robotSerialNumber, CancellationToken ct = default)
    {
        try
        {
            var robot = await _robotRepository.GetByManufacturerAndSerialNumberAsync(robotManufacturer, robotSerialNumber, ct);
            if (robot == null) return false;

            // 获取当前执行中的任务和子任务
            var tasks = await _taskRepository.GetByRobotIdAsync(robot.RobotId, ct);
            var inProgressTask = tasks.FirstOrDefault(t => t.Status == Domain.Entities.TaskStatus.InProgress);
            if (inProgressTask == null) return false;

            var currentSubTask = inProgressTask.SubTasks
                .OrderBy(st => st.Sequence)
                .FirstOrDefault(st => st.Status == Domain.Entities.TaskStatus.Pending
                    || st.Status == Domain.Entities.TaskStatus.InProgress);
            if (currentSubTask == null) return false;

            // 从Redis读取VDA路径缓存
            var cacheKey = $"{_settings.Redis.KeyPrefixes.VdaPath}:{robot.RobotId}:{currentSubTask.TaskId}:{currentSubTask.SubTaskId}";
            var cacheData = await _redis.GetDatabase().StringGetAsync(cacheKey);
            if (cacheData.IsNullOrEmpty) return false;

            var cache = JsonSerializer.Deserialize<VdaSegmentedPathCache>(cacheData.ToString());
            if (cache == null) return false;

            // 判断是否所有段都已发送完毕（与TryCompleteOrderFromStateAsync中相同的判断逻辑）
            var junctionIndex = cache.CurrentJunctionIndex;
            var resourceIndex = cache.CurrentResourceIndex;
            var totalJunctions = cache.JunctionSegments.Count;

            if (junctionIndex >= totalJunctions)
            {
                // 路口段索引已越界 = 全部发送完毕
                return true;
            }

            if (junctionIndex == totalJunctions - 1)
            {
                // 在最后一个路口段，检查资源段是否也全部发送
                var lastJunction = cache.JunctionSegments[junctionIndex];
                return resourceIndex >= lastJunction.ResourceSegments.Count;
            }

            return false;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "判断机器人 {Manufacturer}:{SerialNumber} 是否在最后一段路径失败",
                robotManufacturer, robotSerialNumber);
            // 异常时返回false，允许后续流程继续（SendNextSegmentAsync内部会再次判断）
            return false;
        }
    }

    /// <summary>
    /// 判断机器人当前是否行驶在已下发VDA路径的最后一个原子路径上
    /// 通过缓存获取机器人信息和VDA路径，结合机器人当前位置（最后经过的节点）进行判断
    /// 用于NewBaseRequest判断：只有当机器人在最后一段上时才发送下一段，否则跳过
    /// @author zzy
    /// 2026-02-25 重构：移除仓储查询，改用缓存直接获取VDA路径和机器人位置
    /// </summary>
    /// <param name="robotManufacturer">机器人制造商</param>
    /// <param name="robotSerialNumber">机器人序列号</param>
    /// <param name="ct">取消令牌</param>
    /// <returns>true表示当前正在已下发路径的最后一个原子路径上（可以发送下一段），false表示不在或无法判断（跳过发送）</returns>
    public async Task<bool> IsOnLastSentSegmentAsync(string robotManufacturer, string robotSerialNumber, CancellationToken ct = default)
    {
        try
        {
            // 从缓存获取机器人基础信息（获取RobotId）
            var basicCache = await _robotCacheService.GetBasicAsync(robotManufacturer, robotSerialNumber);
            if (basicCache == null)
            {
                _logger.LogWarning("IsOnLastSentSegmentAsync - 未找到机器人缓存: {Manufacturer}:{SerialNumber}",
                    robotManufacturer, robotSerialNumber);
                return false;
            }

            // 使用通配符查找该机器人VDA路径缓存Key（兼容历史残留/并发场景可能存在多个）
            var pattern = $"{_settings.Redis.KeyPrefixes.VdaPath}:{basicCache.RobotId}:*";
            var server = _redis.GetServer(_redis.GetEndPoints().First());
            var keys = server.Keys(pattern: pattern).ToArray();
            if (keys.Length == 0) return false;

            var db = _redis.GetDatabase();
            VdaSegmentedPathCache? cache = null;
            foreach (var key in keys)
            {
                var keyText = key.ToString();
                if (!IsVdaPathCachePayloadKey(keyText))
                {
                    continue;
                }

                var cacheData = await db.StringGetAsync(key);
                if (cacheData.IsNullOrEmpty)
                {
                    continue;
                }

                VdaSegmentedPathCache? candidate;
                try
                {
                    candidate = JsonSerializer.Deserialize<VdaSegmentedPathCache>(cacheData.ToString());
                }
                catch (Exception ex) when (ex is JsonException or NotSupportedException)
                {
                    _logger.LogDebug("IsOnLastSentSegmentAsync - 跳过无法反序列化的路径缓存Key: {CacheKey}", keyText);
                    continue;
                }

                if (candidate == null || candidate.JunctionSegments.Count == 0)
                {
                    continue;
                }

                if (cache == null || candidate.CreatedAt > cache.CreatedAt)
                {
                    cache = candidate;
                }
            }

            if (cache == null) return false;

            // 从缓存获取机器人最后经过的节点
            var statusCache = await _robotCacheService.GetStatusAsync(robotManufacturer, robotSerialNumber);
            if (statusCache?.LastNode == null) return false;

            // 从后往前遍历所有资源段，找到最后一个已发送的资源段
            VdaSegmentCacheItem? lastSentSegment = null;
            for (var j = cache.JunctionSegments.Count - 1; j >= 0 && lastSentSegment == null; j--)
            {
                var junction = cache.JunctionSegments[j];
                for (var r = junction.ResourceSegments.Count - 1; r >= 0; r--)
                {
                    if (junction.ResourceSegments[r].IsSent)
                    {
                        lastSentSegment = junction.ResourceSegments[r];
                        break;
                    }
                }
            }

            if (lastSentSegment == null || lastSentSegment.Segments.Count == 0) return false;

            // 获取最后一个已发送资源段中的最后一个原子路径
            var lastAtomicPath = lastSentSegment.Segments[^1];

            // 判断机器人最后经过的节点是否在最后一个原子路径上
            // FromNodeId: 机器人正在行驶该边 → 在最后一段上
            // ToNodeId: 机器人已到达该边终点 → 在最后一段上
            var lastPassedNode = statusCache?.LastNode;
            return lastPassedNode == lastAtomicPath.FromNodeCode || lastPassedNode == lastAtomicPath.ToNodeCode;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "判断机器人 {Manufacturer}:{SerialNumber} 是否在当前下发路径的最后一段失败",
                robotManufacturer, robotSerialNumber);
            // 异常时返回false，允许后续流程继续
            return false;
        }
    }

    /// <summary>
    /// 判断是否为VDA路径缓存主体Key（...:{robotId}:{taskId}:{subTaskId}）。
    /// </summary>
    private static bool IsVdaPathCachePayloadKey(string keyText)
    {
        if (string.IsNullOrWhiteSpace(keyText))
        {
            return false;
        }

        var parts = keyText.Split(':', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
        if (parts.Length < 3)
        {
            return false;
        }

        return Guid.TryParse(parts[^3], out _) &&
               Guid.TryParse(parts[^2], out _) &&
               Guid.TryParse(parts[^1], out _);
    }

    /// <summary>
    /// 解析用于完成判断的目标子任务：
    /// 1. 优先使用 State.OrderId（SubTaskId）
    /// 2. 若 OrderId 缺失/无效/非当前执行子任务，则回退到机器人当前执行中的子任务
    /// </summary>
    private async Task<RobotSubTask?> ResolveSubTaskForCompletionAsync(
        Robot robot,
        string? stateOrderId,
        CancellationToken ct)
    {
        // 1) 优先尝试使用 State.OrderId
        if (!string.IsNullOrWhiteSpace(stateOrderId) && Guid.TryParse(stateOrderId, out var orderSubTaskId))
        {
            var orderSubTask = await _subTaskRepository.GetByIdWithDetailsAsync(orderSubTaskId, ct);
            if (orderSubTask != null
                && orderSubTask.RobotId == robot.RobotId
                && orderSubTask.Status == Domain.Entities.TaskStatus.InProgress)
            {
                return orderSubTask;
            }

            _logger.LogDebug(
                "[VDA完成判断] State.OrderId 对应子任务不可用，转为回退匹配: RobotId={RobotId}, StateOrderId={OrderId}",
                robot.RobotId,
                stateOrderId);
        }

        // 2) 回退：根据机器人当前执行任务定位子任务
        var tasks = await _taskRepository.GetByRobotIdAsync(robot.RobotId, ct);
        var inProgressTask = tasks.FirstOrDefault(t => t.Status == Domain.Entities.TaskStatus.InProgress);
        if (inProgressTask == null)
        {
            return null;
        }

        var inProgressSubTask = inProgressTask.SubTasks
            .OrderBy(st => st.Sequence)
            .FirstOrDefault(st => st.Status == Domain.Entities.TaskStatus.InProgress);
        if (inProgressSubTask == null)
        {
            return null;
        }

        return await _subTaskRepository.GetByIdWithDetailsAsync(inProgressSubTask.SubTaskId, ct);
    }

    /// <summary>
    /// 根据VDA5050 State消息判断并处理订单（子任务）完成
    /// 判断条件：未行驶 + NodeStates为空 + EdgeStates为空 + 所有动作完成 + 最后一段已发送
    /// 子任务识别：优先使用State.OrderId，失败时回退到当前执行子任务
    /// @author zzy
    /// </summary>
    /// <param name="robotManufacturer">机器人制造商</param>
    /// <param name="robotSerialNumber">机器人序列号</param>
    /// <param name="stateInfo">VDA5050 State消息数据</param>
    /// <param name="ct">取消令牌</param>
    /// <returns>是否成功触发了完成</returns>
    public async Task<bool> TryCompleteOrderFromStateAsync(
        string robotManufacturer, string robotSerialNumber,
        State stateInfo, CancellationToken ct = default)
    {
        // 机器人必须已停止行驶
        if (stateInfo.Driving)
        {
            return false;
        }

        // NodeStates和EdgeStates必须为空（所有路径已走完）
        if (stateInfo.NodeStates != null && stateInfo.NodeStates.Count > 0)
        {
            return false;
        }
        if (stateInfo.EdgeStates != null && stateInfo.EdgeStates.Count > 0)
        {
            return false;
        }

        // 所有动作必须已完成（不存在未完成的动作）
        if (stateInfo.ActionStates != null && stateInfo.ActionStates.Count > 0)
        {
            var hasUnfinishedAction = stateInfo.ActionStates.Any(a =>
                a.ActionStatus != "FINISHED");
            if (hasUnfinishedAction)
            {
                return false;
            }

            // // 存在FAILED动作时记录警告，但不阻止完成判断
            // var failedActions = stateInfo.ActionStates.Where(a => a.ActionStatus == "FAILED").ToList();
            // if (failedActions.Any())
            // {
            //     _logger.LogWarning(
            //         "[VDA完成判断] 存在失败的动作，但仍继续完成判断: Robot={Manufacturer}:{SerialNumber}, FailedActions={Actions}",
            //         robotManufacturer, robotSerialNumber,
            //         string.Join(",", failedActions.Select(a => $"{a.ActionId}:{a.ActionType}")));
            // }
        }

        var robot = await _robotRepository.GetByManufacturerAndSerialNumberAsync(robotManufacturer, robotSerialNumber, ct);
        if (robot == null)
        {
            _logger.LogWarning("[VDA完成判断] 机器人不存在: {Manufacturer}:{SerialNumber}",
                robotManufacturer, robotSerialNumber);
            return false;
        }

        // 查找对应的子任务：优先使用State.OrderId，失败时回退当前执行子任务
        var subTask = await ResolveSubTaskForCompletionAsync(robot, stateInfo.OrderId, ct);
        var subTaskId = subTask?.SubTaskId;
        if (subTask != null)
        {

            if (subTask.Status == Domain.Entities.TaskStatus.Completed || subTask.Status != Domain.Entities.TaskStatus.InProgress)
            {
                return false;
            }
            // 最够经过的节点为任务终点
            if (string.IsNullOrEmpty(stateInfo.LastNodeId) || stateInfo.LastNodeId != subTask.EndNode?.NodeCode )
            {
                return false;
            }
        }


        // 检查VDA路径缓存，确认是最后一段已发送
        var cacheKey = $"{_settings.Redis.KeyPrefixes.VdaPath}:{robot.RobotId}:{subTask?.TaskId ?? Guid.Empty}:{subTaskId ?? Guid.Empty}";
        var cacheData = await _redis.GetDatabase().StringGetAsync(cacheKey);
        VdaSegmentedPathCache? pathCache = null;

        if (!cacheData.IsNullOrEmpty)
        {
            var cache = JsonSerializer.Deserialize<VdaSegmentedPathCache>(cacheData.ToString());
            if (cache != null)
            {
                pathCache = cache;
                // 判断是否所有段都已发送完毕（两层索引都必须越界）
                // 情况1：CurrentJunctionIndex 已超出路口段总数（最后一个路口段的最后一个资源段发送后递增越界）
                // 情况2：CurrentJunctionIndex 在最后一个路口段，但 CurrentResourceIndex 已超出该路口段的资源段总数
                var junctionIndex = cache.CurrentJunctionIndex;
                var resourceIndex = cache.CurrentResourceIndex;
                var totalJunctions = cache.JunctionSegments.Count;

                bool isAllSegmentsSent;
                if (junctionIndex >= totalJunctions)
                {
                    // 路口段索引已越界 = 全部发送完毕
                    isAllSegmentsSent = true;
                }
                else if (junctionIndex == totalJunctions - 1)
                {
                    // 在最后一个路口段，检查资源段是否也全部发送
                    var lastJunction = cache.JunctionSegments[junctionIndex];
                    isAllSegmentsSent = resourceIndex >= lastJunction.ResourceSegments.Count;
                }
                else
                {
                    // 还有未到达的路口段
                    isAllSegmentsSent = false;
                }

                if (!isAllSegmentsSent)
                {
                    _logger.LogDebug(
                        "[VDA完成判断] 还有未发送的路径段: SubTaskId={SubTaskId}, JunctionIndex={JI}/{JTotal}, ResourceIndex={RI}",
                        subTaskId, junctionIndex, totalJunctions, resourceIndex);
                    return false;
                }
            }
        }

        // 使用分布式锁防止并发完成
        var completionLockKey = $"order_completion_lock:{subTaskId}";
        var lockAcquired = await _redis.GetDatabase().StringSetAsync(
            completionLockKey, "1", TimeSpan.FromSeconds(30), When.NotExists);

        if (!lockAcquired)
        {
            _logger.LogDebug("[VDA完成判断] 完成处理正在进行中，跳过: SubTaskId={SubTaskId}", subTaskId);
            return false;
        }

        try
        {
            // 末段补充：当所有路径段已发送完成时，仍需检查并触发“最后一段终点”的网络动作。
            // 现有机制是在发送下一段前检查上一段终点；末段没有“下一段”，需在完成判断阶段补一次检查。
            if (subTask != null && pathCache != null)
            {
                var tailNetActionCheck = await CheckAndExecuteNetActionsAsync(
                    robot,
                    subTask,
                    pathCache,
                    pathCache.CurrentJunctionIndex,
                    pathCache.CurrentResourceIndex);

                if (!tailNetActionCheck.CanContinue)
                {
                    _logger.LogInformation(
                        "[VDA完成判断] 末段终点网络动作拦截完成: SubTaskId={SubTaskId}, Message={Message}, WaitingAsync={WaitingAsync}",
                        subTask.SubTaskId,
                        tailNetActionCheck.Message,
                        tailNetActionCheck.IsWaitingAsync);
                    return false;
                }
            }

            _logger.LogInformation(
                "[VDA完成判断] 订单完成条件满足，触发子任务完成: Robot={Manufacturer}:{SerialNumber}, SubTaskId={SubTaskId}, TaskId={TaskId}",
                robotManufacturer, robotSerialNumber, subTaskId, subTask?.TaskId);

            // 触发子任务完成（会添加 SubTaskCompletedDomainEvent）
            if (subTask != null)
            {
                subTask.Complete();
                await _subTaskRepository.UpdateAsync(subTask, ct);
                await _subTaskRepository.SaveChangesAsync(ct);
            }
            else
            {
                // 兜底无任务取消VDA订单
                await CancelRobotTasksAsync(robot, ct);
            }

            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "[VDA完成判断] 触发子任务完成失败: SubTaskId={SubTaskId}", subTaskId);
            return false;
        }
        finally
        {
            await _redis.GetDatabase().KeyDeleteAsync(completionLockKey);
        }
    }
}