zengzy / hhrcs_service · Files

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Rcs.Application.Services;
using Rcs.Application.Services.PathFind.Models;
using Rcs.Domain.Settings;
using StackExchange.Redis;

namespace Rcs.Infrastructure.PathFinding.Services
{
    /// <summary>
    /// 统一交通管制服务实现 - 基于 Redis 的分布式地图锁管理
    /// Key格式: "rcs:lock:node:{MapCode}:{NodeCode}" 或 "rcs:lock:edge:{MapCode}:{EdgeCode}"
    /// 支持双向互斥检测：锁定边时自动检查逆向边是否被其他机器人占用
    /// @author zzy
    /// @date 2026-01-30
    /// </summary>
    public class UnifiedTrafficControlService : IUnifiedTrafficControlService
    {
        private readonly ILogger<UnifiedTrafficControlService> _logger;
        private readonly IConnectionMultiplexer _redis;
        private readonly AppSettings _settings;
        private IDatabase RedisDb => _redis.GetDatabase();

        // 逆向边映射 Key: "{MapCode}:{EdgeCode}", Value: "{MapCode}:{ReverseEdgeCode}"
        // 用于双向互斥检测（保留内存缓存，因为地图结构相对固定）
        private readonly Dictionary<string, string> _reverseEdgeMap = new();

        // Redis Hash 字段名常量
        private const string LockFieldRobotId = "rid";
        private const string LockFieldLockedAt = "lat";
        private const string LockFieldExpiresAt = "eat";
        private const string LockFieldFromNode = "frm";
        private const string LockFieldToNode = "to";
        private const string LockFieldHasDirection = "dir";

        public UnifiedTrafficControlService(
            ILogger<UnifiedTrafficControlService> logger,
            IConnectionMultiplexer redis,
            IOptions<AppSettings> settings)
        {
            _logger = logger;
            _redis = redis;
            _settings = settings.Value;
        }

        #region Key生成

        private string BuildNodeKey(string mapCode, string nodeCode) =>
            $"{_settings.Redis.KeyPrefixes.NodeLockPrefix}:{mapCode}:{nodeCode}";

        private string BuildEdgeKey(string mapCode, string edgeCode) =>
            $"{_settings.Redis.KeyPrefixes.EdgeLockPrefix}:{mapCode}:{edgeCode}";

        private string BuildRobotNodesKey(Guid robotId) =>
            $"{_settings.Redis.KeyPrefixes.RobotLockResourcesPrefix}:{robotId}:{_settings.Redis.KeyPrefixes.RobotLockNodesSuffix}";

        private string BuildRobotEdgesKey(Guid robotId) =>
            $"{_settings.Redis.KeyPrefixes.RobotLockResourcesPrefix}:{robotId}:{_settings.Redis.KeyPrefixes.RobotLockEdgesSuffix}";

        #endregion

        #region 逆向边管理（双向互斥检测）

        /// <summary>
        /// 注册逆向边关系（用于双向互斥检测）
        /// @author zzy
        /// </summary>
        public void RegisterReverseEdge(string mapCode, string edgeCode, string? reverseEdgeCode)
        {
            var key = $"{mapCode}:{edgeCode}";
            lock (_reverseEdgeMap)
            {
                if (!string.IsNullOrEmpty(reverseEdgeCode))
                {
                    var reverseKey = $"{mapCode}:{reverseEdgeCode}";
                    _reverseEdgeMap[key] = reverseKey;
                    _reverseEdgeMap[reverseKey] = key;
                    //_logger.LogDebug("注册逆向边关系: {EdgeKey} <-> {ReverseEdgeKey}", key, reverseKey);
                }
                else
                {
                    _reverseEdgeMap.Remove(key);
                }
            }
        }

        /// <summary>
        /// 批量注册逆向边关系
        /// @author zzy
        /// </summary>
        public void RegisterReverseEdges(string mapCode, Dictionary<string, string?> edgeReverseMapping)
        {
            foreach (var (edgeCode, reverseEdgeCode) in edgeReverseMapping)
            {
                RegisterReverseEdge(mapCode, edgeCode, reverseEdgeCode);
            }
            _logger.LogInformation("批量注册逆向边关系完成: MapCode={MapCode}, Count={Count}",
                mapCode, edgeReverseMapping.Count);
        }

        /// <summary>
        /// 清除指定地图的逆向边关系缓存
        /// @author zzy
        /// </summary>
        public void ClearReverseEdgeCache(string mapCode)
        {
            lock (_reverseEdgeMap)
            {
                var keysToRemove = _reverseEdgeMap.Keys.Where(k => k.StartsWith($"{mapCode}:")).ToList();
                foreach (var key in keysToRemove)
                {
                    _reverseEdgeMap.Remove(key);
                }
                _logger.LogInformation("已清除地图 {MapCode} 的逆向边缓存，共 {Count} 条", mapCode, keysToRemove.Count);
            }
        }

        private string? GetReverseEdgeKey(string mapCode, string edgeCode)
        {
            var key = $"{mapCode}:{edgeCode}";
            lock (_reverseEdgeMap)
            {
                return _reverseEdgeMap.TryGetValue(key, out var reverseKey) ? reverseKey : null;
            }
        }

        /// <summary>
        /// 检查逆向边是否被其他机器人锁定
        /// @author zzy
        /// </summary>
        /// <param name="mapCode">地图编码</param>
        /// <param name="edgeCode">边编码</param>
        /// <param name="robotId">机器人ID</param>
        /// <param name="fromNodeCode">起点节点编码（可选，用于构建逆向边编码）</param>
        /// <param name="toNodeCode">终点节点编码（可选，用于构建逆向边编码）</param>
        private async Task<(bool hasConflict, Guid? conflictingRobotId)> CheckReverseEdgeConflictAsync(
            string mapCode, string edgeCode, Guid robotId,
            string? fromNodeCode = null, string? toNodeCode = null)
        {
            string? reverseEdgeCode = null;

            // 优先使用传入的方向信息构建逆向边编码
            if (!string.IsNullOrEmpty(fromNodeCode) && !string.IsNullOrEmpty(toNodeCode))
            {
                reverseEdgeCode = $"{toNodeCode}-{fromNodeCode}";
            }
            else
            {
                // 回退到使用 _reverseEdgeMap
                var reverseKeyInfo = GetReverseEdgeKey(mapCode, edgeCode);
                if (!string.IsNullOrEmpty(reverseKeyInfo))
                {
                    var parts = reverseKeyInfo.Split(':');
                    if (parts.Length == 2)
                    {
                        reverseEdgeCode = parts[1];
                    }
                }
            }

            if (string.IsNullOrEmpty(reverseEdgeCode))
            {
                return (false, null);
            }

            var reverseEdgeLockKey = BuildEdgeKey(mapCode, reverseEdgeCode);
            var lockInfo = await GetLockInfoAsync(reverseEdgeLockKey);

            if (lockInfo != null)
            {
                var now = DateTime.UtcNow;
                if (lockInfo.RobotId != robotId && lockInfo.ExpiresAt > now)
                {
                    // _logger.LogDebug("双向互斥冲突: Edge={EdgeCode}, ReverseEdge={ReverseEdge}, HeldBy={HeldBy}",
                    //     edgeCode, reverseEdgeCode, lockInfo.RobotId);
                    return (true, lockInfo.RobotId);
                }
            }

            return (false, null);
        }

        /// <summary>
        /// 从合并映射初始化逆向边关系
        /// @author zzy
        /// </summary>
        public Task InitializeFromMergedMappingsAsync(Dictionary<string, MergedMapTopology> mergedTopologies)
        {
            if (mergedTopologies == null || mergedTopologies.Count == 0)
            {
                _logger.LogWarning("合并拓扑为空，跳过逆向边初始化");
                return Task.CompletedTask;
            }

            var totalCount = 0;
            foreach (var (mapCode, topology) in mergedTopologies)
            {
                ClearReverseEdgeCache(mapCode);

                if (topology.ReverseEdgeMap != null && topology.ReverseEdgeMap.Count > 0)
                {
                    RegisterReverseEdges(mapCode, topology.ReverseEdgeMap);
                    totalCount += topology.ReverseEdgeMap.Count;
                }
            }

            _logger.LogInformation("从合并映射初始化逆向边关系完成: MapCode数={MapCodeCount}, 逆向边总数={TotalCount}",
                mergedTopologies.Count, totalCount);

            return Task.CompletedTask;
        }

        /// <summary>
        /// 刷新指定MapCode的逆向边关系
        /// @author zzy
        /// </summary>
        public Task RefreshReverseEdgesAsync(string mapCode, MergedMapTopology mergedTopology)
        {
            if (string.IsNullOrEmpty(mapCode) || mergedTopology == null)
            {
                return Task.CompletedTask;
            }

            ClearReverseEdgeCache(mapCode);

            if (mergedTopology.ReverseEdgeMap != null && mergedTopology.ReverseEdgeMap.Count > 0)
            {
                RegisterReverseEdges(mapCode, mergedTopology.ReverseEdgeMap);
                _logger.LogInformation("刷新逆向边关系完成: MapCode={MapCode}, Count={Count}",
                    mapCode, mergedTopology.ReverseEdgeMap.Count);
            }

            return Task.CompletedTask;
        }

        #endregion

        #region 基于Redis的锁操作

        /// <summary>
        /// 从Redis获取锁信息
        /// </summary>
        private async Task<LockInfo?> GetLockInfoAsync(string lockKey)
        {
            var hashEntries = await RedisDb.HashGetAllAsync(lockKey);
            if (hashEntries.Length == 0) return null;

            var dict = hashEntries.ToDictionary(
                e => e.Name.ToString(),
                e => e.Value.ToString());

            if (!dict.TryGetValue(LockFieldRobotId, out var robotIdStr) ||
                !Guid.TryParse(robotIdStr, out var robotId))
            {
                return null;
            }

            return new LockInfo
            {
                RobotId = robotId,
                LockedAt = dict.TryGetValue(LockFieldLockedAt, out var lat) &&
                           long.TryParse(lat, out var latTicks)
                    ? new DateTime(latTicks, DateTimeKind.Utc)
                    : DateTime.MinValue,
                ExpiresAt = dict.TryGetValue(LockFieldExpiresAt, out var eat) &&
                            long.TryParse(eat, out var eatTicks)
                    ? new DateTime(eatTicks, DateTimeKind.Utc)
                    : DateTime.MinValue,
                FromNodeCode = dict.TryGetValue(LockFieldFromNode, out var frm) ? frm : null,
                ToNodeCode = dict.TryGetValue(LockFieldToNode, out var to) ? to : null
            };
        }

        /// <summary>
        /// 设置锁信息到Redis（使用事务保证原子性）
        /// </summary>
        private async Task<bool> SetLockInfoAsync(string lockKey, LockInfo lockInfo, int ttlSeconds)
        {
            var hashEntries = new HashEntry[]
            {
                new(LockFieldRobotId, lockInfo.RobotId.ToString()),
                new(LockFieldLockedAt, lockInfo.LockedAt.Ticks),
                new(LockFieldExpiresAt, lockInfo.ExpiresAt.Ticks)
            };

            await RedisDb.HashSetAsync(lockKey, hashEntries);
            await RedisDb.KeyExpireAsync(lockKey, TimeSpan.FromSeconds(ttlSeconds));
            return true;
        }

        /// <summary>
        /// 尝试锁定节点
        /// @author zzy
        /// </summary>
        public async Task<bool> TryAcquireNodeLockAsync(string mapCode, string nodeCode, Guid robotId, int ttlSeconds = 30)
        {
            var key = BuildNodeKey(mapCode, nodeCode);
            return await TryAcquireLockAsync(key, robotId, ttlSeconds, LockResourceType.Node);
        }

        /// <summary>
        /// 尝试锁定边（包含双向互斥检测）
        /// @author zzy
        /// </summary>
        public async Task<bool> TryAcquireEdgeLockAsync(string mapCode, string edgeCode, Guid robotId, int ttlSeconds = 30)
        {
            var (hasConflict, conflictingRobotId) = await CheckReverseEdgeConflictAsync(mapCode, edgeCode, robotId);
            if (hasConflict)
            {
                // _logger.LogDebug("边锁定失败（双向互斥）: EdgeCode={EdgeCode}, MapCode={MapCode}, ConflictingRobot={ConflictingRobot}",
                //     edgeCode, mapCode, conflictingRobotId);
                return false;
            }

            var key = BuildEdgeKey(mapCode, edgeCode);
            return await TryAcquireLockAsync(key, robotId, ttlSeconds, LockResourceType.Edge);
        }

        /// <summary>
        /// 尝试锁定边（带方向信息，用于区分同向/逆向冲突）
        /// @author zzy
        /// </summary>
        public async Task<bool> TryAcquireEdgeLockWithDirectionAsync(
            string mapCode, string edgeCode, Guid robotId,
            string fromNodeCode, string toNodeCode, int ttlSeconds = 30)
        {
            var (hasConflict, conflictingRobotId) = await CheckReverseEdgeConflictAsync(mapCode, edgeCode, robotId, fromNodeCode, toNodeCode);
            if (hasConflict)
            {
                // _logger.LogDebug("边锁定失败（双向互斥）: EdgeCode={EdgeCode}, MapCode={MapCode}, ConflictingRobot={ConflictingRobot}",
                //     edgeCode, mapCode, conflictingRobotId);
                return false;
            }

            var key = BuildEdgeKey(mapCode, edgeCode);
            return await TryAcquireEdgeLockWithDirectionAsync(key, robotId, fromNodeCode, toNodeCode, ttlSeconds);
        }

        /// <summary>
        /// 带方向信息的边锁获取
        /// @author zzy
        /// </summary>
        private async Task<bool> TryAcquireEdgeLockWithDirectionAsync(
            string key, Guid robotId,
            string fromNodeCode, string toNodeCode, int ttlSeconds)
        {
            var now = DateTime.UtcNow;
            var expiresAt = now.AddSeconds(ttlSeconds);

            // 使用 Lua 脚本保证原子性，包含方向信息
            const string luaScript = @"
                local key = KEYS[1]
                local robotId = ARGV[1]
                local lockedAt = ARGV[2]
                local expiresAt = ARGV[3]
                local ttl = ARGV[4]
                local fromNode = ARGV[5]
                local toNode = ARGV[6]

                local current = redis.call('HGET', key, 'rid')

                if current == false then
                    -- 锁不存在，创建新锁
                    redis.call('HMSET', key, 'rid', robotId, 'lat', lockedAt, 'eat', expiresAt, 'frm', fromNode, 'to', toNode, 'dir', '1')
                    redis.call('EXPIRE', key, ttl)
                    return 1
                elseif current == robotId then
                    -- 同一机器人，续期并更新方向
                    redis.call('HMSET', key, 'eat', expiresAt, 'frm', fromNode, 'to', toNode, 'dir', '1')
                    redis.call('EXPIRE', key, ttl)
                    return 1
                else
                    -- 检查是否过期
                    local currentExpires = redis.call('HGET', key, 'eat')
                    if currentExpires == false or tonumber(currentExpires) < tonumber(lockedAt) then
                        redis.call('HMSET', key, 'rid', robotId, 'lat', lockedAt, 'eat', expiresAt, 'frm', fromNode, 'to', toNode, 'dir', '1')
                        redis.call('EXPIRE', key, ttl)
                        return 1
                    else
                        return 0
                    end
                end
            ";

            var result = (int)await RedisDb.ScriptEvaluateAsync(
                luaScript,
                new RedisKey[] { key },
                new RedisValue[]
                {
                    robotId.ToString(),
                    now.Ticks.ToString(),
                    expiresAt.Ticks.ToString(),
                    ttlSeconds.ToString(),
                    fromNodeCode ?? "",
                    toNodeCode ?? ""
                });

            var success = result == 1;

            if (success)
            {
                // 记录机器人锁定的资源
                var setKey = BuildRobotEdgesKey(robotId);
                await RedisDb.SetAddAsync(setKey, key);
                await RedisDb.KeyExpireAsync(setKey, TimeSpan.FromSeconds(ttlSeconds * 10));

                // _logger.LogDebug("边锁定成功(带方向): Key={Key}, RobotId={RobotId}, Direction={From}->{To}",
                //     key, robotId, fromNodeCode, toNodeCode);
            }
            else
            {
                var holder = await GetLockHolderAsync(key);
                // _logger.LogDebug("边锁定失败: Key={Key}, RobotId={RobotId}, HeldBy={HeldBy}",
                //     key, robotId, holder);
            }

            return success;
        }

        /// <summary>
        /// 通用锁获取逻辑（Redis实现）
        /// </summary>
        private async Task<bool> TryAcquireLockAsync(string key, Guid robotId, int ttlSeconds, LockResourceType resourceType)
        {
            var now = DateTime.UtcNow;
            var expiresAt = now.AddSeconds(ttlSeconds);

            // 使用 Lua 脚本保证原子性
            const string luaScript = @"
                local key = KEYS[1]
                local robotId = ARGV[1]
                local lockedAt = ARGV[2]
                local expiresAt = ARGV[3]
                local ttl = ARGV[4]

                local current = redis.call('HGET', key, 'rid')

                if current == false then
                    -- 锁不存在，创建新锁
                    redis.call('HMSET', key, 'rid', robotId, 'lat', lockedAt, 'eat', expiresAt)
                    redis.call('EXPIRE', key, ttl)
                    return 1
                elseif current == robotId then
                    -- 同一机器人，续期
                    redis.call('HMSET', key, 'eat', expiresAt)
                    redis.call('EXPIRE', key, ttl)
                    return 1
                else
                    -- 检查是否过期
                    local currentExpires = redis.call('HGET', key, 'eat')
                    if currentExpires == false or tonumber(currentExpires) < tonumber(lockedAt) then
                        redis.call('HMSET', key, 'rid', robotId, 'lat', lockedAt, 'eat', expiresAt)
                        redis.call('EXPIRE', key, ttl)
                        return 1
                    else
                        return 0
                    end
                end
            ";

            var result = (int)await RedisDb.ScriptEvaluateAsync(
                luaScript,
                new RedisKey[] { key },
                new RedisValue[]
                {
                    robotId.ToString(),
                    now.Ticks.ToString(),
                    expiresAt.Ticks.ToString(),
                    ttlSeconds.ToString()
                });

            var success = result == 1;

            if (success)
            {
                // 记录机器人锁定的资源
                var setKey = resourceType == LockResourceType.Node
                    ? BuildRobotNodesKey(robotId)
                    : BuildRobotEdgesKey(robotId);
                await RedisDb.SetAddAsync(setKey, key);
                await RedisDb.KeyExpireAsync(setKey, TimeSpan.FromSeconds(ttlSeconds * 10)); // 资源索引TTL更长

                // _logger.LogDebug("锁定成功: Key={Key}, RobotId={RobotId}", key, robotId);
            }
            else
            {
                var holder = await GetLockHolderAsync(key);
                // _logger.LogDebug("锁定失败: Key={Key}, RobotId={RobotId}, HeldBy={HeldBy}",
                //     key, robotId, holder);
            }

            return success;
        }

        /// <summary>
        /// 释放节点锁
        /// @author zzy
        /// </summary>
        public async Task<bool> ReleaseNodeLockAsync(string mapCode, string nodeCode, Guid robotId)
        {
            var key = BuildNodeKey(mapCode, nodeCode);
            return await ReleaseLockAsync(key, robotId, LockResourceType.Node);
        }

        /// <summary>
        /// 释放边锁
        /// @author zzy
        /// </summary>
        public async Task<bool> ReleaseEdgeLockAsync(string mapCode, string edgeCode, Guid robotId)
        {
            var key = BuildEdgeKey(mapCode, edgeCode);
            return await ReleaseLockAsync(key, robotId, LockResourceType.Edge);
        }

        /// <summary>
        /// 通用锁释放逻辑（Redis实现）
        /// </summary>
        private async Task<bool> ReleaseLockAsync(string key, Guid robotId, LockResourceType resourceType)
        {
            const string luaScript = @"
                local key = KEYS[1]
                local robotId = ARGV[1]

                local current = redis.call('HGET', key, 'rid')
                if current == robotId then
                    redis.call('DEL', key)
                    return 1
                else
                    return 0
                end
            ";

            var result = (int)await RedisDb.ScriptEvaluateAsync(
                luaScript,
                new RedisKey[] { key },
                new RedisValue[] { robotId.ToString() });

            if (result == 1)
            {
                // 从机器人资源集合中移除
                var setKey = resourceType == LockResourceType.Node
                    ? BuildRobotNodesKey(robotId)
                    : BuildRobotEdgesKey(robotId);
                await RedisDb.SetRemoveAsync(setKey, key);

                // _logger.LogDebug("释放锁成功: Key={Key}, RobotId={RobotId}", key, robotId);
                return true;
            }

            return false;
        }

        /// <summary>
        /// 批量锁定路径
        /// @author zzy
        /// </summary>
        public async Task<LockRequestResult> TryAcquirePathLocksAsync(
            string mapCode,
            IEnumerable<string> nodeCodes,
            IEnumerable<string> edgeCodes,
            Guid robotId,
            int ttlSeconds = 30)
        {
            var result = new LockRequestResult { Success = true };
            var nodeList = nodeCodes.ToList();
            var edgeList = edgeCodes.ToList();

            var lockedNodeKeys = new List<string>();
            var lockedEdgeKeys = new List<string>();

            try
            {
                // 尝试锁定所有节点
                foreach (var nodeCode in nodeList)
                {
                    var key = BuildNodeKey(mapCode, nodeCode);
                    var locked = await TryAcquireNodeLockAsync(mapCode, nodeCode, robotId, ttlSeconds);

                    if (locked)
                    {
                        lockedNodeKeys.Add(key);
                        result.LockedNodeCodes.Add(nodeCode);
                    }
                    else
                    {
                        result.Success = false;
                        result.ConflictingNodeCodes.Add(nodeCode);

                        var holder = await GetNodeLockHolderAsync(mapCode, nodeCode);
                        if (holder.HasValue && !result.ConflictingRobotIds.Contains(holder.Value))
                        {
                            result.ConflictingRobotIds.Add(holder.Value);
                        }

                        result.FailureReason = $"节点锁定失败: {mapCode}:{nodeCode}";
                        break;
                    }
                }

                // 如果节点锁定成功，继续锁定边
                if (result.Success)
                {
                    foreach (var edgeCode in edgeList)
                    {
                        var key = BuildEdgeKey(mapCode, edgeCode);
                        var locked = await TryAcquireEdgeLockAsync(mapCode, edgeCode, robotId, ttlSeconds);

                        if (locked)
                        {
                            lockedEdgeKeys.Add(key);
                            result.LockedEdgeCodes.Add(edgeCode);
                        }
                        else
                        {
                            result.Success = false;
                            result.ConflictingEdgeCodes.Add(edgeCode);

                            var holder = await GetEdgeLockHolderAsync(mapCode, edgeCode);
                            if (holder.HasValue && !result.ConflictingRobotIds.Contains(holder.Value))
                            {
                                result.ConflictingRobotIds.Add(holder.Value);
                                result.FailureReason = $"边锁定失败（直接占用）: {mapCode}:{edgeCode}";
                            }
                            else
                            {
                                var (hasReverseConflict, reverseHolder) = await CheckReverseEdgeConflictAsync(mapCode, edgeCode, robotId);
                                if (hasReverseConflict && reverseHolder.HasValue && !result.ConflictingRobotIds.Contains(reverseHolder.Value))
                                {
                                    result.ConflictingRobotIds.Add(reverseHolder.Value);
                                }
                                result.FailureReason = $"边锁定失败（双向互斥）: {mapCode}:{edgeCode}";
                            }
                            break;
                        }
                    }
                }

                // 如果失败，回滚所有已锁定的资源
                if (!result.Success)
                {
                    foreach (var nodeCode in result.LockedNodeCodes.ToList())
                    {
                        await ReleaseNodeLockAsync(mapCode, nodeCode, robotId);
                    }
                    foreach (var edgeCode in result.LockedEdgeCodes.ToList())
                    {
                        await ReleaseEdgeLockAsync(mapCode, edgeCode, robotId);
                    }
                    result.LockedNodeCodes.Clear();
                    result.LockedEdgeCodes.Clear();

                    _logger.LogWarning("批量锁定失败并回滚: RobotId={RobotId}, MapCode={MapCode}, Reason={Reason}",
                        robotId, mapCode, result.FailureReason);
                }
                else
                {
                    // _logger.LogDebug("批量锁定成功: RobotId={RobotId}, MapCode={MapCode}, Nodes={NodeCount}, Edges={EdgeCount}",
                        // robotId, mapCode, result.LockedNodeCodes.Count, result.LockedEdgeCodes.Count);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "批量锁定异常: RobotId={RobotId}, MapCode={MapCode}", robotId, mapCode);

                foreach (var nodeCode in result.LockedNodeCodes)
                {
                    await ReleaseNodeLockAsync(mapCode, nodeCode, robotId);
                }
                foreach (var edgeCode in result.LockedEdgeCodes)
                {
                    await ReleaseEdgeLockAsync(mapCode, edgeCode, robotId);
                }

                result.Success = false;
                result.FailureReason = $"锁定异常: {ex.Message}";
                result.LockedNodeCodes.Clear();
                result.LockedEdgeCodes.Clear();
            }

            return result;
        }

        /// <summary>
        /// 批量释放路径锁
        /// @author zzy
        /// </summary>
        public async Task<int> ReleasePathLocksAsync(
            string mapCode,
            IEnumerable<string> nodeCodes,
            IEnumerable<string> edgeCodes,
            Guid robotId)
        {
            var releasedCount = 0;

            foreach (var nodeCode in nodeCodes)
            {
                if (await ReleaseNodeLockAsync(mapCode, nodeCode, robotId))
                {
                    releasedCount++;
                }
            }

            foreach (var edgeCode in edgeCodes)
            {
                if (await ReleaseEdgeLockAsync(mapCode, edgeCode, robotId))
                {
                    releasedCount++;
                }
            }

            // _logger.LogDebug("批量释放锁: RobotId={RobotId}, MapCode={MapCode}, ReleasedCount={Count}",
            //     robotId, mapCode, releasedCount);

            return releasedCount;
        }

        #endregion

        #region 锁状态查询

        /// <summary>
        /// 检查节点是否被锁定
        /// @author zzy
        /// </summary>
        public async Task<LockStatusInfo> GetNodeLockStatusAsync(string mapCode, string nodeCode)
        {
            var key = BuildNodeKey(mapCode, nodeCode);
            return await GetLockStatusAsync(key, nodeCode, LockResourceType.Node);
        }

        /// <summary>
        /// 检查边是否被锁定
        /// @author zzy
        /// </summary>
        public async Task<LockStatusInfo> GetEdgeLockStatusAsync(string mapCode, string edgeCode)
        {
            var key = BuildEdgeKey(mapCode, edgeCode);
            return await GetLockStatusAsync(key, edgeCode, LockResourceType.Edge);
        }

        /// <summary>
        /// 通用锁状态查询（Redis实现）
        /// </summary>
        private async Task<LockStatusInfo> GetLockStatusAsync(string key, string code, LockResourceType resourceType)
        {
            var status = new LockStatusInfo
            {
                ResourceKey = key,
                ResourceCode = code,
                ResourceType = resourceType,
                IsLocked = false
            };

            var lockInfo = await GetLockInfoAsync(key);
            if (lockInfo != null)
            {
                var now = DateTime.UtcNow;
                if (lockInfo.ExpiresAt > now)
                {
                    status.IsLocked = true;
                    status.LockedByRobotId = lockInfo.RobotId;
                    status.LockedAt = lockInfo.LockedAt;
                    status.ExpiresAt = lockInfo.ExpiresAt;
                }
                else
                {
                    // 清理过期锁
                    await RedisDb.KeyDeleteAsync(key);
                }
            }

            return status;
        }

        /// <summary>
        /// 获取节点锁持有者
        /// @author zzy
        /// </summary>
        public async Task<Guid?> GetNodeLockHolderAsync(string mapCode, string nodeCode)
        {
            var key = BuildNodeKey(mapCode, nodeCode);
            return await GetLockHolderAsync(key);
        }

        /// <summary>
        /// 获取边锁持有者
        /// @author zzy
        /// </summary>
        public async Task<Guid?> GetEdgeLockHolderAsync(string mapCode, string edgeCode)
        {
            var key = BuildEdgeKey(mapCode, edgeCode);
            return await GetLockHolderAsync(key);
        }

        /// <summary>
        /// 通用获取锁持有者
        /// </summary>
        private async Task<Guid?> GetLockHolderAsync(string key)
        {
            var lockInfo = await GetLockInfoAsync(key);
            if (lockInfo != null && lockInfo.ExpiresAt > DateTime.UtcNow)
            {
                return lockInfo.RobotId;
            }
            return null;
        }

        /// <summary>
        /// 获取机器人当前锁定的所有资源
        /// @author zzy
        /// </summary>
        public async Task<(List<string> NodeKeys, List<string> EdgeKeys)> GetRobotLockedResourcesAsync(Guid robotId)
        {
            var nodesKey = BuildRobotNodesKey(robotId);
            var edgesKey = BuildRobotEdgesKey(robotId);

            var nodeKeys = await RedisDb.SetMembersAsync(nodesKey);
            var edgeKeys = await RedisDb.SetMembersAsync(edgesKey);

            return (
                nodeKeys.Select(k => k.ToString()).ToList(),
                edgeKeys.Select(k => k.ToString()).ToList()
            );
        }

        #endregion

        #region 全局锁管理

        /// <summary>
        /// 释放机器人的所有锁
        /// @author zzy
        /// </summary>
        public async Task<int> ReleaseAllRobotLocksAsync(Guid robotId)
        {
            var releasedCount = 0;

            var (nodeKeys, edgeKeys) = await GetRobotLockedResourcesAsync(robotId);

            foreach (var key in nodeKeys)
            {
                const string luaScript = @"
                    local key = KEYS[1]
                    local robotId = ARGV[1]
                    local current = redis.call('HGET', key, 'rid')
                    if current == robotId then
                        redis.call('DEL', key)
                        return 1
                    end
                    return 0
                ";

                var result = (int)await RedisDb.ScriptEvaluateAsync(
                    luaScript,
                    new RedisKey[] { key },
                    new RedisValue[] { robotId.ToString() });

                if (result == 1)
                {
                    releasedCount++;
                }
            }

            foreach (var key in edgeKeys)
            {
                const string luaScript = @"
                    local key = KEYS[1]
                    local robotId = ARGV[1]
                    local current = redis.call('HGET', key, 'rid')
                    if current == robotId then
                        redis.call('DEL', key)
                        return 1
                    end
                    return 0
                ";

                var result = (int)await RedisDb.ScriptEvaluateAsync(
                    luaScript,
                    new RedisKey[] { key },
                    new RedisValue[] { robotId.ToString() });

                if (result == 1)
                {
                    releasedCount++;
                }
            }

            // 清理机器人的资源索引
            var nodesSetKey = BuildRobotNodesKey(robotId);
            var edgesSetKey = BuildRobotEdgesKey(robotId);
            await RedisDb.KeyDeleteAsync(nodesSetKey);
            await RedisDb.KeyDeleteAsync(edgesSetKey);

            _logger.LogInformation("释放机器人所有锁: RobotId={RobotId}, ReleasedCount={Count}", robotId, releasedCount);
            return releasedCount;
        }

        /// <summary>
        /// 续期机器人的所有锁
        /// @author zzy
        /// </summary>
        public async Task<int> RenewAllRobotLocksAsync(Guid robotId, int ttlSeconds = 30)
        {
            var renewedCount = 0;
            var newExpiresAt = DateTime.UtcNow.AddSeconds(ttlSeconds);

            var (nodeKeys, edgeKeys) = await GetRobotLockedResourcesAsync(robotId);

            foreach (var key in nodeKeys)
            {
                const string luaScript = @"
                    local key = KEYS[1]
                    local robotId = ARGV[1]
                    local newExpiresAt = ARGV[2]
                    local ttl = ARGV[3]

                    local current = redis.call('HGET', key, 'rid')
                    if current == robotId then
                        redis.call('HSET', key, 'eat', newExpiresAt)
                        redis.call('EXPIRE', key, ttl)
                        return 1
                    end
                    return 0
                ";

                var result = (int)await RedisDb.ScriptEvaluateAsync(
                    luaScript,
                    new RedisKey[] { key },
                    new RedisValue[]
                    {
                        robotId.ToString(),
                        newExpiresAt.Ticks.ToString(),
                        ttlSeconds.ToString()
                    });

                if (result == 1)
                {
                    renewedCount++;
                }
            }

            foreach (var key in edgeKeys)
            {
                const string luaScript = @"
                    local key = KEYS[1]
                    local robotId = ARGV[1]
                    local newExpiresAt = ARGV[2]
                    local ttl = ARGV[3]

                    local current = redis.call('HGET', key, 'rid')
                    if current == robotId then
                        redis.call('HSET', key, 'eat', newExpiresAt)
                        redis.call('EXPIRE', key, ttl)
                        return 1
                    end
                    return 0
                ";

                var result = (int)await RedisDb.ScriptEvaluateAsync(
                    luaScript,
                    new RedisKey[] { key },
                    new RedisValue[]
                    {
                        robotId.ToString(),
                        newExpiresAt.Ticks.ToString(),
                        ttlSeconds.ToString()
                    });

                if (result == 1)
                {
                    renewedCount++;
                }
            }

            // 续期资源索引的TTL
            var nodesSetKey = BuildRobotNodesKey(robotId);
            var edgesSetKey = BuildRobotEdgesKey(robotId);
            await RedisDb.KeyExpireAsync(nodesSetKey, TimeSpan.FromSeconds(ttlSeconds * 10));
            await RedisDb.KeyExpireAsync(edgesSetKey, TimeSpan.FromSeconds(ttlSeconds * 10));

            // _logger.LogDebug("续期机器人锁: RobotId={RobotId}, RenewedCount={Count}", robotId, renewedCount);
            return renewedCount;
        }

        /// <summary>
        /// 获取指定MapCode下所有锁定状态
        /// @author zzy
        /// </summary>
        public async Task<List<LockStatusInfo>> GetAllLockStatusAsync(string mapCode)
        {
            var result = new List<LockStatusInfo>();
            var now = DateTime.UtcNow;

            var nodePrefix = $"{_settings.Redis.KeyPrefixes.NodeLockPrefix}:{mapCode}:";
            var edgePrefix = $"{_settings.Redis.KeyPrefixes.EdgeLockPrefix}:{mapCode}:";

            // 使用 SCAN 遍历节点锁
            var nodeCursor = 0;
            do
            {
                var scanResult = await RedisDb.ScriptEvaluateAsync(
                    "return redis.call('SCAN', ARGV[1], 'MATCH', ARGV[2], 'COUNT', 100)",
                    null,
                    new RedisValue[] { nodeCursor.ToString(), $"{nodePrefix}*" });

                var array = (RedisResult[])scanResult;
                nodeCursor = int.Parse(array[0].ToString());
                var keys = (RedisResult[])array[1];

                foreach (var key in keys)
                {
                    var lockInfo = await GetLockInfoAsync(key.ToString());
                    if (lockInfo != null && lockInfo.ExpiresAt > now)
                    {
                        var code = key.ToString()!.Substring(nodePrefix.Length);
                        result.Add(new LockStatusInfo
                        {
                            ResourceKey = key.ToString()!,
                            ResourceCode = code,
                            ResourceType = LockResourceType.Node,
                            IsLocked = true,
                            LockedByRobotId = lockInfo.RobotId,
                            LockedAt = lockInfo.LockedAt,
                            ExpiresAt = lockInfo.ExpiresAt
                        });
                    }
                }
            } while (nodeCursor != 0);

            // 使用 SCAN 遍历边锁
            var edgeCursor = 0;
            do
            {
                var scanResult = await RedisDb.ScriptEvaluateAsync(
                    "return redis.call('SCAN', ARGV[1], 'MATCH', ARGV[2], 'COUNT', 100)",
                    null,
                    new RedisValue[] { edgeCursor.ToString(), $"{edgePrefix}*" });

                var array = (RedisResult[])scanResult;
                edgeCursor = int.Parse(array[0].ToString());
                var keys = (RedisResult[])array[1];

                foreach (var key in keys)
                {
                    var lockInfo = await GetLockInfoAsync(key.ToString());
                    if (lockInfo != null && lockInfo.ExpiresAt > now)
                    {
                        var code = key.ToString()!.Substring(edgePrefix.Length);
                        result.Add(new LockStatusInfo
                        {
                            ResourceKey = key.ToString()!,
                            ResourceCode = code,
                            ResourceType = LockResourceType.Edge,
                            IsLocked = true,
                            LockedByRobotId = lockInfo.RobotId,
                            LockedAt = lockInfo.LockedAt,
                            ExpiresAt = lockInfo.ExpiresAt
                        });
                    }
                }
            } while (edgeCursor != 0);

            return result;
        }

        #endregion

        #region 冲突检测

        /// <summary>
        /// 检测路径是否与其他机器人冲突
        /// @author zzy
        /// </summary>
        public async Task<PathConflictResult> CheckPathConflictAsync(
            string mapCode,
            IEnumerable<string> nodeCodes,
            IEnumerable<string> edgeCodes,
            Guid robotId,
            Dictionary<string, (string FromNodeCode, string ToNodeCode)>? edgeDirectionMap = null)
        {
            var result = new PathConflictResult { HasConflict = false };
            var now = DateTime.UtcNow;

            var nodeList = nodeCodes.ToList();
            var edgeList = edgeCodes.ToList();

            // 检查节点冲突
            for (int i = 0; i < nodeList.Count; i++)
            {
                var nodeCode = nodeList[i];
                var key = BuildNodeKey(mapCode, nodeCode);

                var lockInfo = await GetLockInfoAsync(key);
                if (lockInfo != null && lockInfo.RobotId != robotId && lockInfo.ExpiresAt > now)
                {
                    result.HasConflict = true;
                    result.FirstConflictIndex ??= i;

                    result.Conflicts.Add(new PathConflictDetail
                    {
                        ResourceKey = key,
                        NodeCode = nodeCode,
                        ConflictType = ConflictType.NodeOccupied,
                        ConflictingRobotId = lockInfo.RobotId,
                        PathIndex = i
                    });
                }
            }

            // 检查边冲突（同向冲突 + 逆向冲突）
            for (int i = 0; i < edgeList.Count; i++)
            {
                var edgeCode = edgeList[i];

                // 1. 检查当前 edgeCode 是否被锁定（同向冲突 - 跟随情况）
                var key = BuildEdgeKey(mapCode, edgeCode);
                var lockInfo = await GetLockInfoAsync(key);

                if (lockInfo != null && lockInfo.RobotId != robotId && lockInfo.ExpiresAt > now)
                {
                    // edgeCode 带方向，被锁定即表示同向行驶，记录但不视为真正冲突
                    result.SameDirectionConflicts.Add(new PathConflictDetail
                    {
                        ResourceKey = key,
                        EdgeCode = edgeCode,
                        ConflictType = ConflictType.EdgeOccupied,
                        ConflictingRobotId = lockInfo.RobotId,
                        PathIndex = i
                    });

                    continue; // 同向边已占用，跳过逆向边检查（同向已锁定，逆向不可能是同一条物理边）
                }
                // 2. 检查逆向边是否被锁定（逆向冲突 - 对向行驶）
                // 根据 edgeDirectionMap 中的起点终点对调构建逆向边 Key
                if (edgeDirectionMap != null &&
                    edgeDirectionMap.TryGetValue(edgeCode, out var direction))
                {
                    // 构建逆向边编码：将起点终点对调
                    var reverseEdgeCode = $"{direction.ToNodeCode}-{direction.FromNodeCode}";
                    var reverseEdgeLockKey = BuildEdgeKey(mapCode, reverseEdgeCode);
                    var reverseLockInfo = await GetLockInfoAsync(reverseEdgeLockKey);

                    if (reverseLockInfo != null && reverseLockInfo.RobotId != robotId && reverseLockInfo.ExpiresAt > now)
                    {
                        // 逆向边被占用，这是对向冲突
                        result.HasConflict = true;
                        result.FirstConflictIndex ??= i;

                        result.Conflicts.Add(new PathConflictDetail
                        {
                            ResourceKey = reverseEdgeLockKey,
                            EdgeCode = edgeCode,
                            ConflictType = ConflictType.HeadOnConflict,
                            ConflictingRobotId = reverseLockInfo.RobotId,
                            PathIndex = i
                        });

                        // _logger.LogDebug("路径冲突检测发现逆向占用: Edge={EdgeCode}, ReverseEdge={ReverseEdge}, ConflictingRobot={ConflictingRobot}",
                        //     edgeCode, reverseEdgeCode, reverseLockInfo.RobotId);
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// 尝试锁定下一段路径，并判断是否存在逆向占用
        /// 用于车辆快到当前段终点时，判断并发送下一段路径指令的场景
        /// 排除同方向边冲突（同方向行驶视为跟随，不冲突）
        /// @author zzy
        /// </summary>
        public async Task<NextSegmentLockResult> TryAcquireNextSegmentLockAsync(
            string mapCode,
            IEnumerable<PathSegmentWithCode> segments,
            Guid robotId,
            int ttlSeconds = 30)
        {
            var result = new NextSegmentLockResult { Success = false };

            var segmentList = segments.ToList();
            var nodeCodes = segmentList
                .Select(s => s.FromNodeCode)
                .Union(segmentList.Select(s => s.ToNodeCode))
                .Distinct()
                .Where(code => !string.IsNullOrEmpty(code))
                .ToList();
            var edgeCodes = segmentList
                .Select(s => s.EdgeCode)
                .Distinct()
                .Where(code => !string.IsNullOrEmpty(code))
                .ToList();

            // 构建边方向映射（用于排除同方向冲突）
            var edgeDirectionMap = segmentList
                .Where(s => !string.IsNullOrEmpty(s.EdgeCode))
                .ToDictionary(
                    s => s.EdgeCode,
                    s => (s.FromNodeCode, s.ToNodeCode));

            // 首先检查路径冲突（传入方向映射以排除同方向冲突）
            var conflictResult = await CheckPathConflictAsync(mapCode, nodeCodes, edgeCodes, robotId, edgeDirectionMap);

            // 检查是否存在逆向冲突（HeadOnConflict）
            var hasReverseConflict = conflictResult.Conflicts.Any(c => c.ConflictType == ConflictType.HeadOnConflict);

            if (hasReverseConflict)
            {
                result.HasReverseConflict = true;
                result.FailureReason = "存在逆向占用冲突";
                // _logger.LogDebug("下一段路径存在逆向占用: RobotId={RobotId}, MapCode={MapCode}",
                //     robotId, mapCode);
                return result;
            }
            # region 后续添加空间碰撞冲突和交叉边冲突再排除同向冲突判定，实现跟随
            // 如果有其他冲突（节点被占用或非同向的边冲突），返回失败
            // if (conflictResult.Conflicts.Any(c => c.ConflictType == ConflictType.NodeOccupied ||
            //                                       c.ConflictType == ConflictType.EdgeOccupied))
            // {
            //     result.HasReverseConflict = false;
            //     var nodeConflicts = conflictResult.Conflicts.Where(c => c.ConflictType == ConflictType.NodeOccupied).ToList();
            //     var edgeConflicts = conflictResult.Conflicts.Where(c => c.ConflictType == ConflictType.EdgeOccupied).ToList();
            //
            //     if (nodeConflicts.Any())
            //     {
            //         result.FailureReason = $"节点被占用: {string.Join(",", nodeConflicts.Select(c => c.NodeCode))}";
            //     }
            //     else if (edgeConflicts.Any())
            //     {
            //         result.FailureReason = $"边被占用（非同向）: {string.Join(",", edgeConflicts.Select(c => c.EdgeCode))}";
            //     }
            //     else
            //     {
            //         result.FailureReason = "路径被其他机器人占用";
            //     }
            //
            //     _logger.LogDebug("下一段路径被占用: RobotId={RobotId}, MapCode={MapCode}, Reason={Reason}",
            //         robotId, mapCode, result.FailureReason);
            //     return result;
            // }
            # endregion

            if (conflictResult.Conflicts.Any() || conflictResult.SameDirectionConflicts.Any())
            {
                if (hasReverseConflict)
                {
                    result.HasReverseConflict = true;
                    result.FailureReason = "存在普通冲突";
                    return result;
                }
            }

            // 尝试锁定节点
            var lockedNodeCodes = new List<string>();
            foreach (var nodeCode in nodeCodes)
            {
                var locked = await TryAcquireNodeLockAsync(mapCode, nodeCode, robotId, ttlSeconds);
                if (locked)
                {
                    lockedNodeCodes.Add(nodeCode);
                }
                else
                {
                    // 锁定失败，回滚已锁定的节点
                    foreach (var lockedNode in lockedNodeCodes)
                    {
                        await ReleaseNodeLockAsync(mapCode, lockedNode, robotId);
                    }
                    result.FailureReason = $"节点锁定失败: {nodeCode}";
                    _logger.LogDebug("下一段路径节点锁定失败: RobotId={RobotId}, MapCode={MapCode}, Node={Node}",
                        robotId, mapCode, nodeCode);
                    return result;
                }
            }

            // 尝试锁定边（使用带方向信息的锁）
            var lockedEdgeCodes = new List<string>();
            foreach (var segment in segmentList.Where(s => !string.IsNullOrEmpty(s.EdgeCode)))
            {
                var locked = await TryAcquireEdgeLockWithDirectionAsync(
                    mapCode, segment.EdgeCode, robotId,
                    segment.FromNodeCode, segment.ToNodeCode, ttlSeconds);

                if (locked)
                {
                    lockedEdgeCodes.Add(segment.EdgeCode);
                }
                else
                {
                    // 锁定失败，回滚所有已锁定的资源
                    foreach (var lockedNode in lockedNodeCodes)
                    {
                        await ReleaseNodeLockAsync(mapCode, lockedNode, robotId);
                    }
                    foreach (var lockedEdge in lockedEdgeCodes)
                    {
                        await ReleaseEdgeLockAsync(mapCode, lockedEdge, robotId);
                    }
                    result.FailureReason = $"边锁定失败: {segment.EdgeCode}";
                    _logger.LogDebug("下一段路径边锁定失败: RobotId={RobotId}, MapCode={MapCode}, Edge={Edge}",
                        robotId, mapCode, segment.EdgeCode);
                    return result;
                }
            }

            result.Success = true;
            result.LockedNodeCodes = lockedNodeCodes;
            result.LockedEdgeCodes = lockedEdgeCodes;

            _logger.LogDebug("下一段路径锁定成功: RobotId={RobotId}, MapCode={MapCode}, Nodes={NodeCount}, Edges={EdgeCount}",
                robotId, mapCode, lockedNodeCodes.Count, lockedEdgeCodes.Count);

            return result;
        }

        #endregion

        #region 内部模型

        private class LockInfo
        {
            public Guid RobotId { get; set; }
            public DateTime LockedAt { get; set; }
            public DateTime ExpiresAt { get; set; }

            /// <summary>
            /// 行驶方向起点节点Code（用于方向判断）
            /// </summary>
            public string? FromNodeCode { get; set; }

            /// <summary>
            /// 行驶方向终点节点Code（用于方向判断）
            /// </summary>
            public string? ToNodeCode { get; set; }

            /// <summary>
            /// 是否有方向信息
            /// </summary>
            public bool HasDirection => !string.IsNullOrEmpty(FromNodeCode) && !string.IsNullOrEmpty(ToNodeCode);
        }

        #endregion
    }
}