zengzy / hhrcs_service · Files

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Rcs.Application.Services;
using Rcs.Application.Services.PathFind;
using Rcs.Application.Services.PathFind.Models;
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.Infrastructure.DB.MsSql;
using Rcs.Infrastructure.PathFinding.Services;
using StackExchange.Redis;
using System.Text.Json;
using Newtonsoft.Json;
using TaskStatus = Rcs.Domain.Entities.TaskStatus;

namespace Rcs.Infrastructure.Services
{
    /// <summary>
    /// 后台任务执行服务 - 将已分配的任务下发给空闲机器人执行
    /// @author zzy
    /// </summary>
    public class TaskExecutionBackgroundService : BackgroundService, ITaskExecutionService
    {
        private readonly ILogger<TaskExecutionBackgroundService> _logger;
        private readonly IServiceScopeFactory _serviceScopeFactory;
        private readonly IRobotCacheService _robotCacheService;
        private readonly IAgvPathService _agvPathService;
        private readonly ITaskLeaseService _taskLeaseService;
        private readonly IConnectionMultiplexer _redis;
        private readonly AppSettings _settings;
        private readonly TimeSpan _executionInterval = TimeSpan.FromSeconds(2);
        private const int MaxAssignedTasksPerCycle = 10;
        private static readonly TimeSpan StarvationCounterTtl = TimeSpan.FromHours(24);
        private static readonly TimeSpan ExecutionStartedLatchTtl = TimeSpan.FromMinutes(10);
        private const string TaskExecutionDeferKeySuffix = "task-exec-defer";
        private const string TaskExecutionStartedLatchKeySuffix = "task-exec-started";

        public TaskExecutionBackgroundService(
            ILogger<TaskExecutionBackgroundService> logger,
            IServiceScopeFactory serviceScopeFactory,
            IRobotCacheService robotCacheService,
            IAgvPathService agvPathService,
            ITaskLeaseService taskLeaseService,
            IConnectionMultiplexer redis,
            IOptions<AppSettings> settings)
        {
            _logger = logger;
            _serviceScopeFactory = serviceScopeFactory;
            _robotCacheService = robotCacheService;
            _agvPathService = agvPathService;
            _taskLeaseService = taskLeaseService;
            _redis = redis;
            _settings = settings.Value;
        }

        /// <summary>
        /// 后台服务执行入口
        /// @author zzy
        /// </summary>
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            _logger.LogInformation("[任务执行] 后台任务执行服务已启动");

            while (!stoppingToken.IsCancellationRequested)
            {
                try
                {
                    await ExecuteTasksAsync(stoppingToken);
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "[任务执行] 执行过程发生异常");
                }

                await Task.Delay(_executionInterval, stoppingToken);
            }

            _logger.LogInformation("[任务执行] 后台任务执行服务已停止");
        }

        /// <summary>
        /// 执行一次任务执行检查
        /// @author zzy
        /// </summary>
        public async Task<TaskExecutionResult> ExecuteTasksAsync(CancellationToken cancellationToken = default)
        {
            using var scope = _serviceScopeFactory.CreateScope();
            var taskRepo = scope.ServiceProvider.GetRequiredService<IRobotTaskRepository>();
            var robotRepo = scope.ServiceProvider.GetRequiredService<IRobotRepository>();

            // 1. 获取已分配和执行中的任务（执行中的任务可能有待执行的子任务）
            var assignedTasks = await taskRepo.GetByStatusAsync(TaskStatus.Assigned, cancellationToken);
            var inProgressTasks = await taskRepo.GetByStatusAsync(TaskStatus.InProgress, cancellationToken);
            
            var activeTasks = assignedTasks
                .Concat(inProgressTasks)
                .Where(t => t.RobotId.HasValue)
                .ToList();

            if (!activeTasks.Any())
            {
                return new TaskExecutionResult { Success = true, ExecutedCount = 0, Message = "无待执行任务" };
            }

            var tasksToExecute = await BuildExecutionQueueAsync(activeTasks, robotRepo, taskRepo, cancellationToken);
            _logger.LogInformation("执行队列{queue}",JsonConvert.SerializeObject(tasksToExecute.Select(t => t.ShelfCode)));
            if (!tasksToExecute.Any())
            {
                return new TaskExecutionResult { Success = true, ExecutedCount = 0, Message = "无待执行任务" };
            }

            int executedCount = 0;

            foreach (var task in tasksToExecute)
            {
                if (!task.RobotId.HasValue) continue;

                // 2. 获取机器人信息
                var robot = await robotRepo.GetByIdFullDataAsync(task.RobotId.Value, cancellationToken);
                if (robot == null)
                {
                    _logger.LogWarning("[任务执行] 任务 {TaskCode} 对应的机器人不存在", task.TaskCode);
                    continue;
                }

                if (!robot.IsRobotAvailable())
                {
                    _logger.LogDebug("[任务执行] 机器人 {RobotCode} 当前不可用", robot.RobotCode);
                    continue;
                }

                // 4. 检查机器人是否有执行中的任务
                var hasInProgressTask = await HasInProgressTaskAsync(robot.RobotId, task.TaskId, taskRepo, cancellationToken);
                
                if (hasInProgressTask)
                {
                    _logger.LogDebug("[任务执行] 机器人 {RobotCode} 存在执行中任务", robot.RobotCode);
                    continue;
                }

                var leaseAcquireResult = await _taskLeaseService.TryAcquireAsync(
                    task.TaskId,
                    robot.RobotId,
                    "execute",
                    cancellationToken);
                if (!leaseAcquireResult.Success || leaseAcquireResult.Lease == null)
                {
                    _logger.LogDebug(
                        "[任务执行] 跳过任务（租约冲突）: TaskCode={TaskCode}, RobotCode={RobotCode}",
                        task.TaskCode,
                        robot.RobotCode);
                    continue;
                }

                // 5. 根据协议类型执行任务
                var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
                dbContext.ChangeTracker.Clear();
                await using var lease = leaseAcquireResult.Lease;
                var success = await ExecuteTaskByProtocolAsync(task, robot, taskRepo, scope, cancellationToken);
                if (success)
                {
                    await SetExecutionStartedLatchAsync(task.TaskId, cancellationToken);
                    executedCount++;
                }
                else
                {
                    await ClearExecutionStartedLatchAsync(task.TaskId, cancellationToken);
                }
            }

            return new TaskExecutionResult
            {
                Success = true,
                ExecutedCount = executedCount,
                Message = $"本次执行完成，已下发 {executedCount} 个任务"
            };
        }

        /// <summary>
        /// 构建执行队列：按机器人分组后，为每台机器人挑选一个最优候选任务。
        /// 候选任务按任务优先级降序（数值越大越优先）排序，
        /// 同优先级按路径代价升序、创建时间毫秒值升序排序（更早创建优先）。
        /// </summary>
        /// <param name="activeTasks">当前活动任务集合（Assigned + InProgress）</param>
        /// <param name="robotRepo">机器人仓储</param>
        /// <param name="taskRepo">任务仓储</param>
        /// <param name="cancellationToken">取消令牌</param>
        /// <returns>本轮待执行任务列表</returns>
        private async Task<List<RobotTask>> BuildExecutionQueueAsync(
            IEnumerable<RobotTask> activeTasks,
            IRobotRepository robotRepo,
            IRobotTaskRepository taskRepo,
            CancellationToken cancellationToken)
        {
            var selectedCandidates = new List<TaskCandidate>();
            var mapGraphCache = new Dictionary<Guid, PathGraph?>();

            // 按机器人分组，每个机器人每轮最多选择一个“下一下发任务”
            var taskGroups = activeTasks
                .Where(t => t.RobotId.HasValue)
                .GroupBy(t => t.RobotId!.Value);

            foreach (var taskGroup in taskGroups)
            {
                var robot = await robotRepo.GetByIdFullDataAsync(taskGroup.Key, cancellationToken);
                if (robot == null)
                {
                    continue;
                }
                // 判断机器人是否仍在执行：只看“执行中子任务”，不依赖主任务状态
                var hasInProgressSubTask = taskGroup.Any(t =>
                    t.SubTasks.Any(st => st.Status == TaskStatus.InProgress));
                if (hasInProgressSubTask)
                {
                    continue;
                }

                var candidateTasks = new List<TaskCandidate>();
                foreach (var task in taskGroup)
                {
                    var taskWithDetails = await taskRepo.GetByIdWithDetailsAsync(task.TaskId, cancellationToken);
                    if (taskWithDetails == null)
                    {
                        continue;
                    }

                    if (!taskWithDetails.SubTasks.Any() && taskWithDetails.Status == TaskStatus.InProgress)
                    {
                        continue;
                    }

                    var nextSubTask = taskWithDetails.GetNextExecutableSubTask();
                    if (taskWithDetails.SubTasks.Any() && nextSubTask == null)
                    {
                        continue;
                    }

                    var pathEvaluation = await CalculatePathCostToTaskAsync(
                        robot,
                        taskWithDetails,
                        nextSubTask,
                        mapGraphCache,
                        cancellationToken);
                    if (pathEvaluation.PathCost == double.MaxValue)
                    {
                        continue;
                    }

                    candidateTasks.Add(new TaskCandidate(
                        taskWithDetails,
                        nextSubTask,
                        pathEvaluation.PathCost,
                        pathEvaluation.Segments,
                        CalculateCompletionRatio(taskWithDetails)));
                }

                if (!candidateTasks.Any())
                {
                    continue;
                }

                TaskCandidate? selectedTask;
                if (_settings.TaskExecution.EnableCompositeSelection)
                {
                    selectedTask = await SelectTaskWithCompositeRulesAsync(robot.RobotId, candidateTasks, cancellationToken);
                }
                else
                {
                    // 先按任务优先级降序，再按路径代价升序、创建时间毫秒值升序与 TaskId 做稳定排序
                    selectedTask = candidateTasks
                        .OrderBy(c => c, TaskCandidateComparer.Instance)
                        .FirstOrDefault();
                }

                if (selectedTask != null)
                {
                    // CalculatePathAsync 会更新机器人规划路径，需确保最终状态与选中任务一致。
                    if (candidateTasks.Count > 1)
                    {
                        await CalculatePathCostToTaskAsync(
                            robot,
                            selectedTask.Task,
                            selectedTask.NextSubTask,
                            mapGraphCache,
                            cancellationToken);
                    }

                    if (_settings.TaskExecution.EnableCompositeSelection)
                    {
                        await UpdateStarvationGuardStateAsync(robot.RobotId, candidateTasks, selectedTask.Task.TaskId, cancellationToken);
                    }

                    selectedCandidates.Add(selectedTask);
                }
            }

            return selectedCandidates
                .OrderBy(c => c, TaskCandidateComparer.Instance)
                .Select(c => c.Task)
                .Take(MaxAssignedTasksPerCycle)
                .ToList();
        }

        /// <summary>
        /// 计算机器人到候选任务目标点的可行路径总代价。
        /// 若路径规划发生异常，则回退为当前位置到对应子任务终点的欧几里得保底代价；
        /// 若关键数据缺失，返回 <see cref="double.MaxValue"/>。
        /// </summary>
        /// <param name="robot">机器人实体</param>
        /// <param name="task">候选任务</param>
        /// <param name="nextSubTask">候选任务的下一子任务</param>
        /// <param name="mapGraphCache">地图图缓存，避免重复加载</param>
        /// <param name="cancellationToken">取消令牌</param>
        /// <returns>可行路径总代价与路径段集合</returns>
        private async Task<PathCostEvaluation> CalculatePathCostToTaskAsync(
            Robot robot,
            RobotTask task,
            RobotSubTask? nextSubTask,
            IDictionary<Guid, PathGraph?> mapGraphCache,
            CancellationToken cancellationToken)
        {
            var targetNodeId = nextSubTask?.EndNodeId
                ?? task.BeginLocation?.MapNode?.NodeId
                ?? task.EndLocation?.MapNode?.NodeId;
            if (!targetNodeId.HasValue || targetNodeId.Value == Guid.Empty)
            {
                return PathCostEvaluation.Invalid;
            }

            var mapId = nextSubTask?.EndNode?.MapId
                ?? task.BeginLocation?.MapNode
                ?.MapId
                ?? task.EndLocation?.MapNode
                ?.MapId
                ?? robot.CurrentMapCodeId;
            if (!mapId.HasValue)
            {
                return PathCostEvaluation.Invalid;
            }

            if (!mapGraphCache.TryGetValue(mapId.Value, out var graph))
            {
                graph = await _agvPathService.GetOrBuildGraphAsync(mapId.Value);
                mapGraphCache[mapId.Value] = graph;
            }

            if (graph == null || !graph.Nodes.TryGetValue(targetNodeId.Value, out var targetPathNode))
            {
                return PathCostEvaluation.Invalid;
            }

            var startNodeId = ResolveStartNodeId(robot, graph);
            if (!startNodeId.HasValue)
            {
                return PathCostEvaluation.Invalid;
            }

            var request = new PathRequest
            {
                RobotId = robot.RobotId,
                MapId = mapId.Value,
                StartNodeId = startNodeId.Value,
                EndNodeId = targetNodeId.Value,
                CurrentTheta = robot.CurrentTheta ?? 0d,
                IsLoaded = !string.IsNullOrWhiteSpace(task.ContainerID),
                Priority = task.Priority,
                BatteryLevel = robot.BatteryLevel ?? 100,
                MovementType = robot.MovementType,
                ForkRadOffsets = robot.ForkRadOffset,
                RequiredEndRad = targetPathNode.Theta
            };

            try
            {
                var pathResult = await _agvPathService.CalculatePathAsync(request, cancellationToken);
                if (!pathResult.Success)
                {
                    throw new Exception($"[任务执行] 候选任务不可达，跳过: RobotCode={robot.RobotCode}, TaskCode={task.TaskCode}, Reason={pathResult.ErrorMessage}");
                }

                if (double.IsNaN(pathResult.TotalCost) || double.IsInfinity(pathResult.TotalCost))
                {
                    throw new Exception($"[任务执行] 候选任务路径代价无效，跳过: RobotCode={robot.RobotCode}, TaskCode={task.TaskCode}, TotalCost={pathResult.TotalCost}");
                }

                return new PathCostEvaluation(pathResult.TotalCost, pathResult.Segments);
            }
            catch (Exception ex)
            {
                var fallbackCost = CalculateFallbackDistanceToSubTaskEndCost(robot, task, nextSubTask, graph);
                if (fallbackCost != double.MaxValue)
                {
                    _logger.LogWarning(
                        ex,
                        "[任务执行] 计算候选任务路径代价异常，走兜底(当前位置->子任务终点/主任务起点欧几里得): RobotCode={RobotCode}, TaskCode={TaskCode}, FallbackCost={FallbackCost:F3}",
                        robot.RobotCode,
                        task.TaskCode,
                        fallbackCost);
                    return new PathCostEvaluation(fallbackCost, Array.Empty<PathSegment>());
                }

                _logger.LogWarning(
                    ex,
                    "[任务执行] 计算候选任务路径代价异常，且无法计算兜底距离，跳过: RobotCode={RobotCode}, TaskCode={TaskCode}",
                    robot.RobotCode,
                    task.TaskCode);
                return PathCostEvaluation.Invalid;
            }
        }

        /// <summary>
        /// 路径规划异常时的保底代价：
        /// 有子任务时，机器人当前位置到子任务终点的欧几里得距离；
        /// 无子任务时，机器人当前位置到主任务起点的欧几里得距离。
        /// </summary>
        private static double CalculateFallbackDistanceToSubTaskEndCost(
            Robot robot,
            RobotTask task,
            RobotSubTask? nextSubTask,
            PathGraph? graph)
        {
            var sourceX = robot.CurrentX ?? robot.MapNode?.X;
            var sourceY = robot.CurrentY ?? robot.MapNode?.Y;
            if (!sourceX.HasValue || !sourceY.HasValue)
            {
                return double.MaxValue;
            }

            double? targetX;
            double? targetY;

            if (nextSubTask != null)
            {
                targetX = nextSubTask.EndNode?.X;
                targetY = nextSubTask.EndNode?.Y;

                if ((!targetX.HasValue || !targetY.HasValue)
                    && graph != null
                    && graph.Nodes.TryGetValue(nextSubTask.EndNodeId, out var endNode))
                {
                    targetX = endNode.X;
                    targetY = endNode.Y;
                }
            }
            else
            {
                var beginNodeId = task.BeginLocation?.MapNode?.NodeId;
                targetX = task.BeginLocation?.MapNode?.X;
                targetY = task.BeginLocation?.MapNode?.Y;

                if ((!targetX.HasValue || !targetY.HasValue)
                    && beginNodeId.HasValue
                    && graph != null
                    && graph.Nodes.TryGetValue(beginNodeId.Value, out var beginNode))
                {
                    targetX = beginNode.X;
                    targetY = beginNode.Y;
                }
            }

            if (!targetX.HasValue || !targetY.HasValue)
            {
                return double.MaxValue;
            }

            return CalculateEuclideanDistance(
                sourceX.Value,
                sourceY.Value,
                targetX.Value,
                targetY.Value);
        }

        private static double CalculateEuclideanDistance(double x1, double y1, double x2, double y2)
        {
            var dx = x1 - x2;
            var dy = y1 - y2;
            return Math.Sqrt((dx * dx) + (dy * dy));
        }

        /// <summary>
        /// 解析机器人在图中的起始节点：
        /// 优先使用当前节点ID；若缺失则按当前位置坐标匹配最近节点。
        /// </summary>
        private static Guid? ResolveStartNodeId(Robot robot, PathGraph graph)
        {
            if (robot.CurrentNodeId.HasValue && graph.Nodes.ContainsKey(robot.CurrentNodeId.Value))
            {
                return robot.CurrentNodeId.Value;
            }

            var sourceX = robot.CurrentX ?? robot.MapNode?.X;
            var sourceY = robot.CurrentY ?? robot.MapNode?.Y;
            if (!sourceX.HasValue || !sourceY.HasValue || graph.Nodes.Count == 0)
            {
                return null;
            }

            Guid? nearestNodeId = null;
            var nearestDistanceSquared = double.MaxValue;

            foreach (var node in graph.Nodes.Values)
            {
                if (!node.Active)
                {
                    continue;
                }

                var dx = sourceX.Value - node.X;
                var dy = sourceY.Value - node.Y;
                var distanceSquared = dx * dx + dy * dy;
                if (distanceSquared < nearestDistanceSquared)
                {
                    nearestDistanceSquared = distanceSquared;
                    nearestNodeId = node.NodeId;
                }
            }

            return nearestNodeId;
        }

        private async Task<TaskCandidate?> SelectTaskWithCompositeRulesAsync(
            Guid robotId,
            IReadOnlyCollection<TaskCandidate> candidateTasks,
            CancellationToken cancellationToken)
        {
            var starvationForced = await TrySelectTaskByStarvationGuardAsync(robotId, candidateTasks, cancellationToken);
            if (starvationForced != null)
            {
                return starvationForced;
            }

            var primary = candidateTasks
                .OrderBy(c => c, CompositePrimaryComparer.Instance)
                .FirstOrDefault();
            if (primary == null)
            {
                return null;
            }

            var decisionInputs = candidateTasks
                .Select(c => new ExecutionCandidateInput(
                    c.Task.TaskId,
                    c.Task.Priority,
                    c.CompletionRatio,
                    c.PathCost,
                    c.CreatedAtMilliseconds,
                    c.Task.TaskId == primary.Task.TaskId
                        ? 0d
                        : CalculateNonOverlapDistance(c.PathSegments, primary.PathSegments)))
                .ToList();

            var decision = SelectExecutionCandidate(
                decisionInputs,
                _settings.TaskExecution.EqualPriorityNonOverlapThreshold,
                _settings.TaskExecution.LowerPriorityNonOverlapThreshold);

            if (decision is null)
            {
                return primary;
            }

            var selected = candidateTasks.FirstOrDefault(c => c.Task.TaskId == decision.Value.SelectedTaskId) ?? primary;

            _logger.LogInformation(
                "[任务执行] 综合排序选中: RobotId={RobotId}, T1={T1TaskId}, Selected={SelectedTaskId}, Bucket={Bucket}",
                robotId,
                decision.Value.PrimaryTaskId,
                decision.Value.SelectedTaskId,
                decision.Value.Bucket);

            return selected;
        }

        private async Task<TaskCandidate?> TrySelectTaskByStarvationGuardAsync(
            Guid robotId,
            IReadOnlyCollection<TaskCandidate> candidateTasks,
            CancellationToken cancellationToken)
        {
            if (!_settings.TaskExecution.EnableStarvationGuard)
            {
                return null;
            }

            var maxDefers = Math.Max(1, _settings.TaskExecution.StarvationGuardMaxDefers);
            var db = _redis.GetDatabase();
            var forced = new List<TaskCandidate>();

            foreach (var candidate in candidateTasks)
            {
                cancellationToken.ThrowIfCancellationRequested();
                if (!ShouldTrackForStarvationGuard(candidate))
                {
                    continue;
                }

                var key = BuildDeferCounterKey(robotId, candidate.Task.TaskId);
                var deferCountValue = await db.StringGetAsync(key);
                if (!deferCountValue.HasValue || !long.TryParse(deferCountValue.ToString(), out var deferCount))
                {
                    continue;
                }

                if (deferCount >= maxDefers)
                {
                    forced.Add(candidate);
                }
            }

            if (!forced.Any())
            {
                return null;
            }

            var selected = forced
                .OrderBy(c => c, CompositePrimaryComparer.Instance)
                .First();

            _logger.LogInformation(
                "[任务执行] 饥饿保护触发强制执行: RobotId={RobotId}, TaskId={TaskId}, MaxDefers={MaxDefers}",
                robotId,
                selected.Task.TaskId,
                maxDefers);

            return selected;
        }

        private async Task UpdateStarvationGuardStateAsync(
            Guid robotId,
            IReadOnlyCollection<TaskCandidate> candidateTasks,
            Guid selectedTaskId,
            CancellationToken cancellationToken)
        {
            if (!_settings.TaskExecution.EnableStarvationGuard)
            {
                return;
            }

            try
            {
                var db = _redis.GetDatabase();
                foreach (var candidate in candidateTasks)
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    var key = BuildDeferCounterKey(robotId, candidate.Task.TaskId);

                    if (!ShouldTrackForStarvationGuard(candidate))
                    {
                        await db.KeyDeleteAsync(key);
                        continue;
                    }

                    if (candidate.Task.TaskId == selectedTaskId)
                    {
                        await db.KeyDeleteAsync(key);
                        continue;
                    }

                    await db.StringIncrementAsync(key);
                    await db.KeyExpireAsync(key, StarvationCounterTtl);
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "[任务执行] 饥饿保护计数更新失败: RobotId={RobotId}", robotId);
            }
        }

        private string BuildDeferCounterKey(Guid robotId, Guid taskId)
        {
            return $"{_settings.Redis.KeyPrefixes.Robot}:{TaskExecutionDeferKeySuffix}:{robotId}:{taskId}";
        }

        private static bool ShouldTrackForStarvationGuard(TaskCandidate candidate)
        {
            return candidate.NextSubTask != null
                   && candidate.Task.SubTasks.Count > 0
                   && candidate.CompletionRatio > 0d
                   && candidate.CompletionRatio < 1d;
        }

        private static double CalculateCompletionRatio(RobotTask task)
        {
            var totalSubTasks = task.SubTasks.Count;
            if (totalSubTasks == 0)
            {
                return 0d;
            }

            // Skip 语义在实体层通过 Completed 状态落库，因此这里按 Completed 统计即可覆盖 Completed+Skipped。
            var completedSubTasks = task.SubTasks.Count(st => st.Status == TaskStatus.Completed);
            return (double)completedSubTasks / totalSubTasks;
        }

        private static double CalculateNonOverlapDistance(
            IReadOnlyList<PathSegment> candidateSegments,
            IReadOnlyList<PathSegment> primarySegments)
        {
            if (candidateSegments.Count == 0 || primarySegments.Count == 0)
            {
                return double.MaxValue;
            }

            var primaryEdgeIds = primarySegments
                .Where(s => s.EdgeId != Guid.Empty)
                .Select(s => s.EdgeId)
                .ToHashSet();
            if (primaryEdgeIds.Count == 0)
            {
                return double.MaxValue;
            }

            var candidateRealSegments = candidateSegments
                .Where(s => s.EdgeId != Guid.Empty)
                .ToList();
            if (candidateRealSegments.Count == 0)
            {
                return double.MaxValue;
            }

            return candidateRealSegments
                .Where(s => !primaryEdgeIds.Contains(s.EdgeId))
                .Sum(s => s.Length);
        }

        internal static ExecutionCandidateDecision? SelectExecutionCandidate(
            IReadOnlyCollection<ExecutionCandidateInput> candidateInputs,
            double equalPriorityThreshold,
            double lowerPriorityThreshold)
        {
            if (candidateInputs.Count == 0)
            {
                return null;
            }

            var primary = candidateInputs
                .OrderBy(c => c, CompositePrimaryInputComparer.Instance)
                .First();

            var equalPrioritySelected = candidateInputs
                .Where(c => c.TaskId != primary.TaskId
                            && c.Priority == primary.Priority
                            && c.NonOverlapDistance <= equalPriorityThreshold)
                .OrderBy(c => c.NonOverlapDistance)
                .ThenBy(c => c.CreatedAtMilliseconds)
                .ThenBy(c => c.TaskId)
                .Select(c => (ExecutionCandidateInput?)c)
                .FirstOrDefault();

            if (equalPrioritySelected.HasValue)
            {
                return new ExecutionCandidateDecision(
                    equalPrioritySelected.Value.TaskId,
                    primary.TaskId,
                    CandidateSelectionBucket.EqualPriorityReplacement);
            }

            var lowerPrioritySelected = candidateInputs
                .Where(c => c.TaskId != primary.TaskId
                            && c.Priority < primary.Priority
                            && c.NonOverlapDistance <= lowerPriorityThreshold)
                .OrderBy(c => c.NonOverlapDistance)
                .ThenBy(c => c.CreatedAtMilliseconds)
                .ThenBy(c => c.TaskId)
                .Select(c => (ExecutionCandidateInput?)c)
                .FirstOrDefault();

            if (lowerPrioritySelected.HasValue)
            {
                return new ExecutionCandidateDecision(
                    lowerPrioritySelected.Value.TaskId,
                    primary.TaskId,
                    CandidateSelectionBucket.LowerPriorityReplacement);
            }

            return new ExecutionCandidateDecision(
                primary.TaskId,
                primary.TaskId,
                CandidateSelectionBucket.Primary);
        }

        /// <summary>
        /// 候选任务评分上下文。
        /// 封装单个候选任务的排序比较信息。
        /// </summary>
        private sealed class TaskCandidate
        {
            public TaskCandidate(
                RobotTask task,
                RobotSubTask? nextSubTask,
                double pathCost,
                IReadOnlyList<PathSegment> pathSegments,
                double completionRatio)
            {
                Task = task;
                NextSubTask = nextSubTask;
                PathCost = pathCost;
                PathSegments = pathSegments;
                CompletionRatio = completionRatio;
                CreatedAtMilliseconds = task.CreatedAt.Ticks / TimeSpan.TicksPerMillisecond;
            }

            public RobotTask Task { get; }
            public RobotSubTask? NextSubTask { get; }
            public double PathCost { get; }
            public IReadOnlyList<PathSegment> PathSegments { get; }
            public double CompletionRatio { get; }
            public long CreatedAtMilliseconds { get; }
        }

        /// <summary>
        /// 历史默认排序：先按任务优先级降序，再按路径代价升序、创建时间毫秒值升序与 TaskId 做稳定排序。
        /// </summary>
        private sealed class TaskCandidateComparer : IComparer<TaskCandidate>
        {
            public static readonly TaskCandidateComparer Instance = new();

            public int Compare(TaskCandidate? x, TaskCandidate? y)
            {
                if (ReferenceEquals(x, y)) return 0;
                if (x is null) return 1;
                if (y is null) return -1;

                var priorityCompare = y.Task.Priority.CompareTo(x.Task.Priority);
                if (priorityCompare != 0)
                {
                    return priorityCompare;
                }

                var pathCostCompare = x.PathCost.CompareTo(y.PathCost);
                if (pathCostCompare != 0)
                {
                    return pathCostCompare;
                }

                var createdAtCompare = x.CreatedAtMilliseconds.CompareTo(y.CreatedAtMilliseconds);
                if (createdAtCompare != 0)
                {
                    return createdAtCompare;
                }

                return x.Task.TaskId.CompareTo(y.Task.TaskId);
            }
        }

        private sealed class CompositePrimaryComparer : IComparer<TaskCandidate>
        {
            public static readonly CompositePrimaryComparer Instance = new();

            public int Compare(TaskCandidate? x, TaskCandidate? y)
            {
                if (ReferenceEquals(x, y)) return 0;
                if (x is null) return 1;
                if (y is null) return -1;

                var priorityCompare = y.Task.Priority.CompareTo(x.Task.Priority);
                if (priorityCompare != 0)
                {
                    return priorityCompare;
                }

                var completionCompare = y.CompletionRatio.CompareTo(x.CompletionRatio);
                if (completionCompare != 0)
                {
                    return completionCompare;
                }

                var pathCostCompare = x.PathCost.CompareTo(y.PathCost);
                if (pathCostCompare != 0)
                {
                    return pathCostCompare;
                }

                var createdAtCompare = x.CreatedAtMilliseconds.CompareTo(y.CreatedAtMilliseconds);
                if (createdAtCompare != 0)
                {
                    return createdAtCompare;
                }

                return x.Task.TaskId.CompareTo(y.Task.TaskId);
            }
        }

        private sealed class CompositePrimaryInputComparer : IComparer<ExecutionCandidateInput>
        {
            public static readonly CompositePrimaryInputComparer Instance = new();

            public int Compare(ExecutionCandidateInput x, ExecutionCandidateInput y)
            {
                var priorityCompare = y.Priority.CompareTo(x.Priority);
                if (priorityCompare != 0)
                {
                    return priorityCompare;
                }

                var completionCompare = y.CompletionRatio.CompareTo(x.CompletionRatio);
                if (completionCompare != 0)
                {
                    return completionCompare;
                }

                var pathCostCompare = x.PathCost.CompareTo(y.PathCost);
                if (pathCostCompare != 0)
                {
                    return pathCostCompare;
                }

                var createdAtCompare = x.CreatedAtMilliseconds.CompareTo(y.CreatedAtMilliseconds);
                if (createdAtCompare != 0)
                {
                    return createdAtCompare;
                }

                return x.TaskId.CompareTo(y.TaskId);
            }
        }

        private sealed record PathCostEvaluation(double PathCost, IReadOnlyList<PathSegment> Segments)
        {
            public static PathCostEvaluation Invalid { get; } =
                new(double.MaxValue, Array.Empty<PathSegment>());
        }

        internal readonly record struct ExecutionCandidateInput(
            Guid TaskId,
            int Priority,
            double CompletionRatio,
            double PathCost,
            long CreatedAtMilliseconds,
            double NonOverlapDistance);

        internal readonly record struct ExecutionCandidateDecision(
            Guid SelectedTaskId,
            Guid PrimaryTaskId,
            CandidateSelectionBucket Bucket);

        internal enum CandidateSelectionBucket
        {
            Primary = 0,
            EqualPriorityReplacement = 1,
            LowerPriorityReplacement = 2
        }

        /// <summary>
        /// 检查机器人是否有执行中的任务
        /// @author zzy
        /// </summary>
        private async Task<bool> HasInProgressTaskAsync(
            Guid robotId,
            Guid taskId,
            IRobotTaskRepository taskRepo,
            CancellationToken cancellationToken)
        {
            var robotTasks = await taskRepo.GetByRobotIdAsync(robotId, cancellationToken);
            return robotTasks.Any(t =>
                t.TaskId != taskId &&
                t.SubTasks.Any(st => st.Status == TaskStatus.InProgress));
        }

        /// <summary>
        /// 根据协议类型执行任务
        /// @author zzy
        /// 重构为使用协议工厂模式
        /// </summary>
        private async Task<bool> ExecuteTaskByProtocolAsync(
            RobotTask task,
            Robot robot,
            IRobotTaskRepository taskRepo,
            IServiceScope scope,
            CancellationToken cancellationToken)
        {
            try
            {
                // 使用同一scope的taskRepo获取带详情的任务，避免跨scope实体跟踪冲突
                var taskWithDetails = await taskRepo.GetByIdWithDetailsAsync(task.TaskId, cancellationToken);
                if (taskWithDetails == null)
                {
                    _logger.LogWarning("[任务执行] 任务 {TaskCode} 详情获取失败", task.TaskCode);
                    return false;
                }

                if (taskWithDetails.RobotId != robot.RobotId)
                {
                    _logger.LogWarning(
                        "[任务执行] 任务机器人已变更，放弃下发: TaskCode={TaskCode}, ExpectedRobot={ExpectedRobot}, ActualRobot={ActualRobot}",
                        taskWithDetails.TaskCode,
                        robot.RobotId,
                        taskWithDetails.RobotId);
                    return false;
                }

                if (taskWithDetails.Status != TaskStatus.Assigned && taskWithDetails.Status != TaskStatus.InProgress)
                {
                    _logger.LogWarning(
                        "[任务执行] 任务状态已变更，放弃下发: TaskCode={TaskCode}, Status={Status}",
                        taskWithDetails.TaskCode,
                        taskWithDetails.Status);
                    return false;
                }
                if (taskWithDetails.SubTasks.Count <= 0 && robot.ProtocolType == ProtocolType.VDA)
                {
                    _logger.LogWarning("[任务执行] 任务 {TaskCode} 不存在子任务，执行失败", task.TaskCode);
                    return false;
                }

                // 获取协议服务工厂
                var protocolServiceFactory = scope.ServiceProvider.GetRequiredService<IProtocolServiceFactory>();
                var protocolService = protocolServiceFactory.GetService(robot);

                // 执行任务
                var res = await protocolService.PrepareSendOrderAsync(robot, taskWithDetails, cancellationToken);

                if (res.Success)
                {
                    taskWithDetails.StartExecution();
                    await taskRepo.UpdateAsync(taskWithDetails, cancellationToken);
                    await taskRepo.SaveChangesAsync(cancellationToken);

                    if (IsDeferredProtocolSuccess(res.Message))
                    {
                        _logger.LogInformation(
                            "[任务执行] 任务 {TaskCode} 已进入调度等待，尚未实际下发给机器人 {RobotCode}，协议类型: {ProtocolType}, Message={Message}",
                            taskWithDetails.TaskCode,
                            robot.RobotCode,
                            robot.ProtocolType,
                            res.Message);
                    }
                    else
                    {
                        _logger.LogInformation(
                            "[任务执行] 任务 {TaskCode} 已下发给机器人 {RobotCode}，协议类型: {ProtocolType}",
                            taskWithDetails.TaskCode,
                            robot.RobotCode,
                            robot.ProtocolType);
                    }

                    return true;
                }
                else
                {
                    throw new Exception(res.Message);
                }
            }
            catch (Exception ex)
            {
                try
                {
                    var taskForErrorUpdate = await taskRepo.GetByIdAsync(task.TaskId, cancellationToken);
                    if (taskForErrorUpdate != null)
                    {
                        taskForErrorUpdate.ErrorInfo = ex.Message.ToString();
                        taskForErrorUpdate.UpdatedAt = DateTime.Now;
                        await taskRepo.UpdateAsync(taskForErrorUpdate, cancellationToken);
                        await taskRepo.SaveChangesAsync(cancellationToken);
                    }
                }
                catch (Exception updateEx)
                {
                    _logger.LogError(updateEx, "[任务执行] 任务 {TaskCode} 错误信息更新失败", task.TaskCode);
                }

                _logger.LogError(ex, "[任务执行] 任务 {TaskCode} 执行失败", task.TaskCode);
                return false;
            }
        }

        private static bool IsDeferredProtocolSuccess(string? message)
        {
            if (string.IsNullOrWhiteSpace(message))
            {
                return false;
            }

            return message.Contains("等待", StringComparison.OrdinalIgnoreCase) ||
                   message.Contains("冲突", StringComparison.OrdinalIgnoreCase) ||
                   message.Contains("并发更新", StringComparison.OrdinalIgnoreCase) ||
                   message.Contains("未到", StringComparison.OrdinalIgnoreCase) ||
                   message.Contains("失败", StringComparison.OrdinalIgnoreCase);
        }

        private async Task SetExecutionStartedLatchAsync(Guid taskId, CancellationToken cancellationToken)
        {
            try
            {
                cancellationToken.ThrowIfCancellationRequested();
                var key = BuildExecutionStartedLatchKey(taskId);
                await _redis.GetDatabase().StringSetAsync(
                    key,
                    DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
                    ExecutionStartedLatchTtl);
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (Exception ex)
            {
                _logger.LogDebug(ex, "[任务执行] 设置执行开始门闩失败: TaskId={TaskId}", taskId);
            }
        }

        private async Task ClearExecutionStartedLatchAsync(Guid taskId, CancellationToken cancellationToken)
        {
            try
            {
                cancellationToken.ThrowIfCancellationRequested();
                await _redis.GetDatabase().KeyDeleteAsync(BuildExecutionStartedLatchKey(taskId));
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (Exception ex)
            {
                _logger.LogDebug(ex, "[任务执行] 删除执行开始门闩失败: TaskId={TaskId}", taskId);
            }
        }

        private string BuildExecutionStartedLatchKey(Guid taskId)
        {
            return $"{_settings.Redis.KeyPrefixes.TaskLeasePrefix}:{TaskExecutionStartedLatchKeySuffix}:{taskId}";
        }
    }
}