zengzy / hhrcs_service · Files

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
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";
        private const string LockFieldBindings = "bindings";

        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}";

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

        private string BuildBindingIndexKey(Guid robotId, string bindingId) =>
            $"{BuildRobotBindingsKey(robotId)}:{bindingId}";

        #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;
            }
        }

        private string? ExtractEdgeCodeFromReverseKey(string mapCode, string reverseKey)
        {
            var prefix = $"{mapCode}:";
            if (reverseKey.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
            {
                return reverseKey.Substring(prefix.Length);
            }

            var separatorIndex = reverseKey.LastIndexOf(':');
            if (separatorIndex >= 0 && separatorIndex < reverseKey.Length - 1)
            {
                return reverseKey.Substring(separatorIndex + 1);
            }

            return reverseKey;
        }

        private string? ResolveReverseEdgeCode(
            string mapCode,
            string edgeCode,
            string? fromNodeCode = null,
            string? toNodeCode = null)
        {
            var reverseKeyInfo = GetReverseEdgeKey(mapCode, edgeCode);
            if (!string.IsNullOrEmpty(reverseKeyInfo))
            {
                var reverseEdgeCodeFromMap = ExtractEdgeCodeFromReverseKey(mapCode, reverseKeyInfo);
                if (!string.IsNullOrEmpty(reverseEdgeCodeFromMap))
                {
                    return reverseEdgeCodeFromMap;
                }
            }

            if (!string.IsNullOrEmpty(fromNodeCode) && !string.IsNullOrEmpty(toNodeCode))
            {
                return $"{toNodeCode}-{fromNodeCode}";
            }

            return 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)
        {
            var reverseEdgeCode = ResolveReverseEdgeCode(mapCode, edgeCode, fromNodeCode, toNodeCode);

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

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

            if (lockInfo != null)
            {
                var now = DateTime.Now;
                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<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.Now;
            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.Now;
            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;
        }

        private async Task<BindingAcquireResult> TryAcquireBindingNodeLockAsync(
            string mapCode,
            string nodeCode,
            Guid robotId,
            string bindingId,
            int ttlSeconds)
        {
            var key = BuildNodeKey(mapCode, nodeCode);
            var acquireResult = await TryAcquireBindingLockAsync(
                key,
                robotId,
                bindingId,
                ttlSeconds,
                LockResourceType.Node);

            if (!acquireResult.Success && !acquireResult.InvalidLegacyFormat)
            {
                acquireResult.ConflictingRobotId = await GetNodeLockHolderAsync(mapCode, nodeCode);
                acquireResult.FailureReason ??= $"节点锁定失败: {nodeCode}";
            }

            return acquireResult;
        }

        private async Task<BindingAcquireResult> TryAcquireBindingEdgeLockAsync(
            string mapCode,
            VdaLockCoveredEdge coveredEdge,
            Guid robotId,
            string bindingId,
            int ttlSeconds)
        {
            var reverseConflict = await CheckReverseEdgeConflictAsync(
                mapCode,
                coveredEdge.EdgeCode,
                robotId,
                coveredEdge.FromNodeCode,
                coveredEdge.ToNodeCode);
            if (reverseConflict.hasConflict)
            {
                return new BindingAcquireResult
                {
                    Success = false,
                    HasReverseConflict = true,
                    FailureReason = $"边锁定失败（双向互斥）: {coveredEdge.EdgeCode}",
                    ConflictingRobotId = reverseConflict.conflictingRobotId
                };
            }

            var key = BuildEdgeKey(mapCode, coveredEdge.EdgeCode);
            var acquireResult = await TryAcquireBindingLockAsync(
                key,
                robotId,
                bindingId,
                ttlSeconds,
                LockResourceType.Edge,
                coveredEdge.FromNodeCode,
                coveredEdge.ToNodeCode);

            if (!acquireResult.Success && !acquireResult.InvalidLegacyFormat)
            {
                acquireResult.ConflictingRobotId = await GetEdgeLockHolderAsync(mapCode, coveredEdge.EdgeCode);
                acquireResult.FailureReason ??= $"边锁定失败: {coveredEdge.EdgeCode}";
            }

            return acquireResult;
        }

        private async Task<BindingAcquireResult> TryAcquireBindingLockAsync(
            string key,
            Guid robotId,
            string bindingId,
            int ttlSeconds,
            LockResourceType resourceType,
            string? fromNodeCode = null,
            string? toNodeCode = null)
        {
            var now = DateTime.Now;
            var expiresAt = now.AddSeconds(ttlSeconds);

            const string luaScript = @"
                local key = KEYS[1]
                local robotId = ARGV[1]
                local lockedAt = ARGV[2]
                local expiresAt = ARGV[3]
                local ttl = ARGV[4]
                local bindingId = ARGV[5]
                local fromNode = ARGV[6]
                local toNode = ARGV[7]
                local hasDirection = ARGV[8]

                local current = redis.call('HGET', key, 'rid')
                local function buildBindings()
                    return cjson.encode({ bindingId })
                end

                if current == false then
                    redis.call('HMSET', key, 'rid', robotId, 'lat', lockedAt, 'eat', expiresAt, 'bindings', buildBindings(), 'frm', fromNode, 'to', toNode, 'dir', hasDirection)
                    redis.call('EXPIRE', key, ttl)
                    return 1
                end

                local currentBindingsRaw = redis.call('HGET', key, 'bindings')
                if currentBindingsRaw == false then
                    return -2
                end

                local currentExpires = redis.call('HGET', key, 'eat')
                if current ~= robotId then
                    if currentExpires == false or tonumber(currentExpires) < tonumber(lockedAt) then
                        redis.call('HMSET', key, 'rid', robotId, 'lat', lockedAt, 'eat', expiresAt, 'bindings', buildBindings(), 'frm', fromNode, 'to', toNode, 'dir', hasDirection)
                        redis.call('EXPIRE', key, ttl)
                        return 1
                    end
                    return 0
                end

                local bindings = cjson.decode(currentBindingsRaw)
                local exists = false
                for _, existing in ipairs(bindings) do
                    if existing == bindingId then
                        exists = true
                        break
                    end
                end
                if not exists then
                    table.insert(bindings, bindingId)
                end

                redis.call('HMSET', key, 'eat', expiresAt, 'bindings', cjson.encode(bindings), 'frm', fromNode, 'to', toNode, 'dir', hasDirection)
                redis.call('EXPIRE', key, ttl)
                if exists then
                    return 2
                end
                return 1
            ";

            var scriptResult = (int)await RedisDb.ScriptEvaluateAsync(
                luaScript,
                new RedisKey[] { key },
                new RedisValue[]
                {
                    robotId.ToString(),
                    now.Ticks.ToString(),
                    expiresAt.Ticks.ToString(),
                    ttlSeconds.ToString(),
                    bindingId,
                    fromNodeCode ?? string.Empty,
                    toNodeCode ?? string.Empty,
                    resourceType == LockResourceType.Edge ? "1" : "0"
                });

            if (scriptResult == -2)
            {
                return new BindingAcquireResult
                {
                    Success = false,
                    InvalidLegacyFormat = true,
                    FailureReason = $"发现旧格式锁数据，无法按严格 binding 模式继续: {key}"
                };
            }

            if (scriptResult is 1 or 2)
            {
                var resourceSetKey = resourceType == LockResourceType.Node
                    ? BuildRobotNodesKey(robotId)
                    : BuildRobotEdgesKey(robotId);
                await RedisDb.SetAddAsync(resourceSetKey, key);
                await RedisDb.KeyExpireAsync(resourceSetKey, TimeSpan.FromSeconds(ttlSeconds * 10));

                return new BindingAcquireResult { Success = true };
            }

            return new BindingAcquireResult { Success = false };
        }

        private async Task SaveBindingIndexAsync(
            string mapCode,
            Guid robotId,
            string bindingId,
            IEnumerable<string> nodeCodes,
            IEnumerable<VdaLockCoveredEdge> coveredEdges,
            int ttlSeconds)
        {
            var bindingIndexKey = BuildBindingIndexKey(robotId, bindingId);
            var robotBindingsKey = BuildRobotBindingsKey(robotId);
            var resourceKeys = nodeCodes
                .Where(code => !string.IsNullOrWhiteSpace(code))
                .Select(code => BuildNodeKey(mapCode, code))
                .Concat(coveredEdges
                    .Where(edge => !string.IsNullOrWhiteSpace(edge.EdgeCode))
                    .Select(edge => BuildEdgeKey(mapCode, edge.EdgeCode)))
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .Select(key => (RedisValue)key)
                .ToArray();

            if (resourceKeys.Length > 0)
            {
                await RedisDb.SetAddAsync(bindingIndexKey, resourceKeys);
            }

            await RedisDb.KeyExpireAsync(bindingIndexKey, TimeSpan.FromSeconds(ttlSeconds));
            await RedisDb.SetAddAsync(robotBindingsKey, bindingIndexKey);
            await RedisDb.KeyExpireAsync(robotBindingsKey, TimeSpan.FromSeconds(ttlSeconds * 10));
        }

        private async Task<List<string>> GetBindingResourceKeysStrictAsync(
            Guid robotId,
            string bindingId,
            bool allowAlreadyReleased)
        {
            var bindingIndexKey = BuildBindingIndexKey(robotId, bindingId);
            var resourceKeys = (await RedisDb.SetMembersAsync(bindingIndexKey))
                .Select(member => member.ToString())
                .Where(key => !string.IsNullOrWhiteSpace(key))
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .ToList();

            if (resourceKeys.Count > 0)
            {
                return resourceKeys;
            }

            if (allowAlreadyReleased)
            {
                if (await HasActiveBindingResourceAsync(robotId, bindingId))
                {
                    throw new InvalidOperationException(
                        $"严格 binding 反向索引缺失，但资源锁仍携带该 BindingId，无法继续释放: {bindingIndexKey}");
                }

                return new List<string>();
            }

            throw new InvalidOperationException(
                $"严格 binding 反向索引缺失或为空，无法继续: {bindingIndexKey}");
        }

        private async Task<bool> HasActiveBindingResourceAsync(Guid robotId, string bindingId)
        {
            var (nodeKeys, edgeKeys) = await GetRobotLockedResourcesAsync(robotId);
            foreach (var resourceKey in nodeKeys
                         .Concat(edgeKeys)
                         .Where(key => !string.IsNullOrWhiteSpace(key))
                         .Distinct(StringComparer.OrdinalIgnoreCase))
            {
                var lockInfo = await GetLockInfoAsync(resourceKey);
                if (lockInfo?.BindingIds.Contains(bindingId, StringComparer.OrdinalIgnoreCase) == true)
                {
                    return true;
                }
            }

            return false;
        }

        private async Task ValidateBindingResourcesAsync(
            Guid robotId,
            string bindingId,
            IReadOnlyCollection<string> resourceKeys)
        {
            var now = DateTime.Now;
            foreach (var resourceKey in resourceKeys)
            {
                var lockInfo = await GetLockInfoAsync(resourceKey);
                if (lockInfo == null)
                {
                    throw new InvalidOperationException(
                        $"严格 binding 资源锁缺失，无法继续: BindingId={bindingId}, ResourceKey={resourceKey}");
                }

                if (lockInfo.RobotId != robotId)
                {
                    throw new InvalidOperationException(
                        $"严格 binding 资源锁持有者不匹配，无法继续: BindingId={bindingId}, ResourceKey={resourceKey}, ExpectedRobotId={robotId}, ActualRobotId={lockInfo.RobotId}");
                }

                if (lockInfo.ExpiresAt <= now)
                {
                    throw new InvalidOperationException(
                        $"严格 binding 资源锁已过期，无法继续: BindingId={bindingId}, ResourceKey={resourceKey}");
                }

                if (lockInfo.BindingIds.Count == 0)
                {
                    throw new InvalidOperationException(
                        $"发现旧格式或损坏的锁数据，无法按严格 binding 模式继续: BindingId={bindingId}, ResourceKey={resourceKey}");
                }

                if (!lockInfo.BindingIds.Contains(bindingId, StringComparer.OrdinalIgnoreCase))
                {
                    throw new InvalidOperationException(
                        $"严格 binding 资源锁未绑定指定 BindingId，无法继续: BindingId={bindingId}, ResourceKey={resourceKey}");
                }
            }
        }

        private async Task RenewBindingResourcesAsync(
            Guid robotId,
            string bindingId,
            IReadOnlyCollection<string> resourceKeys,
            int ttlSeconds)
        {
            if (resourceKeys.Count == 0)
            {
                return;
            }

            var expiresAt = DateTime.Now.AddSeconds(ttlSeconds);

            const string luaScript = @"
                local key = KEYS[1]
                local robotId = ARGV[1]
                local newExpiresAt = ARGV[2]
                local ttl = ARGV[3]
                local bindingId = ARGV[4]

                local current = redis.call('HGET', key, 'rid')
                if current == false then
                    return -2
                end

                if current ~= robotId then
                    return 0
                end

                local rawBindings = redis.call('HGET', key, 'bindings')
                if rawBindings == false then
                    return -1
                end

                local bindings = cjson.decode(rawBindings)
                local exists = false
                for _, existing in ipairs(bindings) do
                    if existing == bindingId then
                        exists = true
                        break
                    end
                end

                if not exists then
                    return -3
                end

                redis.call('HSET', key, 'eat', newExpiresAt)
                redis.call('EXPIRE', key, ttl)
                return 1
            ";

            foreach (var resourceKey in resourceKeys)
            {
                var renewResult = (int)await RedisDb.ScriptEvaluateAsync(
                    luaScript,
                    new RedisKey[] { resourceKey },
                    new RedisValue[]
                    {
                        robotId.ToString(),
                        expiresAt.Ticks.ToString(),
                        ttlSeconds.ToString(),
                        bindingId
                    });

                if (renewResult != 1)
                {
                    throw new InvalidOperationException(
                        $"严格 binding 资源锁续期失败，无法继续: BindingId={bindingId}, ResourceKey={resourceKey}, Result={renewResult}");
                }
            }
        }

        private async Task ReleaseBindingResourcesDirectAsync(
            string mapCode,
            Guid robotId,
            string bindingId,
            IEnumerable<string> nodeCodes,
            IEnumerable<string> edgeCodes)
        {
            foreach (var nodeCode in nodeCodes
                         .Where(code => !string.IsNullOrWhiteSpace(code))
                         .Distinct(StringComparer.OrdinalIgnoreCase))
            {
                var key = BuildNodeKey(mapCode, nodeCode);
                var releaseResult = await ReleaseBindingFromResourceKeyAsync(key, robotId, bindingId);
                if (releaseResult == BindingReleaseResult.ResourceDeleted)
                {
                    await RedisDb.SetRemoveAsync(BuildRobotNodesKey(robotId), key);
                }
            }

            foreach (var edgeCode in edgeCodes
                         .Where(code => !string.IsNullOrWhiteSpace(code))
                         .Distinct(StringComparer.OrdinalIgnoreCase))
            {
                var key = BuildEdgeKey(mapCode, edgeCode);
                var releaseResult = await ReleaseBindingFromResourceKeyAsync(key, robotId, bindingId);
                if (releaseResult == BindingReleaseResult.ResourceDeleted)
                {
                    await RedisDb.SetRemoveAsync(BuildRobotEdgesKey(robotId), key);
                }
            }
        }

        private async Task<BindingReleaseResult> ReleaseBindingFromResourceKeyAsync(
            string key,
            Guid robotId,
            string bindingId)
        {
            const string luaScript = @"
                local key = KEYS[1]
                local robotId = ARGV[1]
                local bindingId = ARGV[2]

                local current = redis.call('HGET', key, 'rid')
                if current == false then
                    return 0
                end

                if current ~= robotId then
                    return 0
                end

                local rawBindings = redis.call('HGET', key, 'bindings')
                if rawBindings == false then
                    return -1
                end

                local bindings = cjson.decode(rawBindings)
                local updated = {}
                local removed = false
                for _, existing in ipairs(bindings) do
                    if existing == bindingId then
                        removed = true
                    else
                        table.insert(updated, existing)
                    end
                end

                if not removed then
                    return 0
                end

                if #updated == 0 then
                    redis.call('DEL', key)
                    return 2
                end

                redis.call('HSET', key, 'bindings', cjson.encode(updated))
                return 1
            ";

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

            return scriptResult switch
            {
                2 => BindingReleaseResult.ResourceDeleted,
                1 => BindingReleaseResult.BindingRemoved,
                -1 => BindingReleaseResult.InvalidLegacyFormat,
                _ => BindingReleaseResult.NoChange
            };
        }

        private BindingLockRequestResult NormalizeBindingLockResult(BindingLockRequestResult result)
        {
            result.LockedBindingIds = result.LockedBindingIds
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .ToList();
            result.LockedNodeCodes = result.LockedNodeCodes
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .ToList();
            result.LockedEdgeCodes = result.LockedEdgeCodes
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .ToList();
            result.ConflictingRobotIds = result.ConflictingRobotIds
                .Distinct()
                .ToList();
            return result;
        }

        /// <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.Now;
                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.Now)
            {
                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);
            var bindingsSetKey = BuildRobotBindingsKey(robotId);
            var nodesSetKey = BuildRobotNodesKey(robotId);
            var edgesSetKey = BuildRobotEdgesKey(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++;
                    await RedisDb.SetRemoveAsync(nodesSetKey, key);
                }
            }

            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++;
                    await RedisDb.SetRemoveAsync(edgesSetKey, key);
                }
            }

            // 清理空的资源索引，保留仍持有（例如当前节点锁）的索引数据
            if (await RedisDb.SetLengthAsync(nodesSetKey) == 0)
            {
                await RedisDb.KeyDeleteAsync(nodesSetKey);
            }

            if (await RedisDb.SetLengthAsync(edgesSetKey) == 0)
            {
                await RedisDb.KeyDeleteAsync(edgesSetKey);
            }

            var bindingKeys = await RedisDb.SetMembersAsync(bindingsSetKey);
            if (bindingKeys.Length > 0)
            {
                foreach (var bindingKey in bindingKeys)
                {
                    await RedisDb.KeyDeleteAsync(bindingKey.ToString());
                }
            }

            await RedisDb.KeyDeleteAsync(bindingsSetKey);

            _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.Now.AddSeconds(ttlSeconds);

            var (nodeKeys, edgeKeys) = await GetRobotLockedResourcesAsync(robotId);
            var bindingsSetKey = BuildRobotBindingsKey(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));
            await RedisDb.KeyExpireAsync(bindingsSetKey, TimeSpan.FromSeconds(ttlSeconds * 10));

            var bindingKeys = await RedisDb.SetMembersAsync(bindingsSetKey);
            foreach (var bindingKey in bindingKeys)
            {
                await RedisDb.KeyExpireAsync(bindingKey.ToString(), TimeSpan.FromSeconds(ttlSeconds));
            }

            // _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.Now;

            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.Now;

            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
                string? fromNodeCode = null;
                string? toNodeCode = null;
                if (edgeDirectionMap != null && edgeDirectionMap.TryGetValue(edgeCode, out var direction))
                {
                    fromNodeCode = direction.FromNodeCode;
                    toNodeCode = direction.ToNodeCode;
                }

                var reverseEdgeCode = ResolveReverseEdgeCode(mapCode, edgeCode, fromNodeCode, toNodeCode);
                if (!string.IsNullOrEmpty(reverseEdgeCode))
                {
                    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))
                .GroupBy(s => s.EdgeCode, StringComparer.OrdinalIgnoreCase)
                .ToDictionary(
                    g => g.Key,
                    g =>
                    {
                        var preferred = g.FirstOrDefault(s => !string.IsNullOrEmpty(s.FromNodeCode) && !string.IsNullOrEmpty(s.ToNodeCode))
                            ?? g.First();
                        return (preferred.FromNodeCode, preferred.ToNodeCode);
                    },
                    StringComparer.OrdinalIgnoreCase);

            // 首先检查路径冲突（传入方向映射以排除同方向冲突）
            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;
        }

        public async Task<BindingLockRequestResult> TryAcquireBindingsAsync(
            string mapCode,
            Guid robotId,
            IEnumerable<BindingLockRequest> bindings,
            int ttlSeconds = 30)
        {
            var result = new BindingLockRequestResult { Success = true };
            var newlyLockedBindingIds = new List<string>();
            var bindingList = bindings
                .Where(binding => !string.IsNullOrWhiteSpace(binding.BindingId))
                .ToList();

            foreach (var binding in bindingList)
            {
                var bindingIndexKey = BuildBindingIndexKey(robotId, binding.BindingId);
                if (await RedisDb.KeyExistsAsync(bindingIndexKey))
                {
                    var existingResourceKeys = await GetBindingResourceKeysStrictAsync(
                        robotId,
                        binding.BindingId,
                        allowAlreadyReleased: false);
                    await ValidateBindingResourcesAsync(robotId, binding.BindingId, existingResourceKeys);
                    await RenewBindingResourcesAsync(robotId, binding.BindingId, existingResourceKeys, ttlSeconds);

                    result.LockedBindingIds.Add(binding.BindingId);
                    result.LockedNodeCodes.AddRange(binding.CoveredNodeCodes
                        .Where(code => !string.IsNullOrWhiteSpace(code))
                        .Distinct(StringComparer.OrdinalIgnoreCase));
                    result.LockedEdgeCodes.AddRange(binding.CoveredEdges
                        .Where(edge => !string.IsNullOrWhiteSpace(edge.EdgeCode))
                        .Select(edge => edge.EdgeCode)
                        .Distinct(StringComparer.OrdinalIgnoreCase));
                    await RedisDb.KeyExpireAsync(bindingIndexKey, TimeSpan.FromSeconds(ttlSeconds));
                    await RedisDb.KeyExpireAsync(BuildRobotBindingsKey(robotId), TimeSpan.FromSeconds(ttlSeconds * 10));
                    continue;
                }

                var acquiredNodeCodes = new List<string>();
                var acquiredEdges = new List<VdaLockCoveredEdge>();

                foreach (var nodeCode in binding.CoveredNodeCodes
                             .Where(code => !string.IsNullOrWhiteSpace(code))
                             .Distinct(StringComparer.OrdinalIgnoreCase))
                {
                    var nodeAcquire = await TryAcquireBindingNodeLockAsync(mapCode, nodeCode, robotId, binding.BindingId, ttlSeconds);
                    if (!nodeAcquire.Success)
                    {
                        result.Success = false;
                        result.HasReverseConflict = nodeAcquire.HasReverseConflict;
                        result.FailureReason = nodeAcquire.FailureReason;
                        if (nodeAcquire.ConflictingRobotId.HasValue)
                        {
                            result.ConflictingRobotIds.Add(nodeAcquire.ConflictingRobotId.Value);
                        }

                        await ReleaseBindingResourcesDirectAsync(
                            mapCode,
                            robotId,
                            binding.BindingId,
                            acquiredNodeCodes,
                            acquiredEdges.Select(edge => edge.EdgeCode));
                        await RollbackBindingsAsync(mapCode, robotId, newlyLockedBindingIds);
                        result.LockedBindingIds.Clear();
                        result.LockedNodeCodes.Clear();
                        result.LockedEdgeCodes.Clear();
                        return NormalizeBindingLockResult(result);
                    }

                    acquiredNodeCodes.Add(nodeCode);
                    result.LockedNodeCodes.Add(nodeCode);
                }

                foreach (var coveredEdge in binding.CoveredEdges
                             .Where(edge => !string.IsNullOrWhiteSpace(edge.EdgeCode))
                             .GroupBy(edge => edge.EdgeCode, StringComparer.OrdinalIgnoreCase)
                             .Select(group => group.First()))
                {
                    var edgeAcquire = await TryAcquireBindingEdgeLockAsync(
                        mapCode,
                        coveredEdge,
                        robotId,
                        binding.BindingId,
                        ttlSeconds);
                    if (!edgeAcquire.Success)
                    {
                        result.Success = false;
                        result.HasReverseConflict = edgeAcquire.HasReverseConflict;
                        result.FailureReason = edgeAcquire.FailureReason;
                        if (edgeAcquire.ConflictingRobotId.HasValue)
                        {
                            result.ConflictingRobotIds.Add(edgeAcquire.ConflictingRobotId.Value);
                        }

                        await ReleaseBindingResourcesDirectAsync(
                            mapCode,
                            robotId,
                            binding.BindingId,
                            acquiredNodeCodes,
                            acquiredEdges.Select(edge => edge.EdgeCode));
                        await RollbackBindingsAsync(mapCode, robotId, newlyLockedBindingIds);
                        result.LockedBindingIds.Clear();
                        result.LockedNodeCodes.Clear();
                        result.LockedEdgeCodes.Clear();
                        return NormalizeBindingLockResult(result);
                    }

                    acquiredEdges.Add(coveredEdge);
                    result.LockedEdgeCodes.Add(coveredEdge.EdgeCode);
                }

                await SaveBindingIndexAsync(mapCode, robotId, binding.BindingId, acquiredNodeCodes, acquiredEdges, ttlSeconds);
                newlyLockedBindingIds.Add(binding.BindingId);
                result.LockedBindingIds.Add(binding.BindingId);
            }

            return NormalizeBindingLockResult(result);
        }

        public async Task<int> ReleaseBindingsAsync(
            string mapCode,
            Guid robotId,
            IEnumerable<string> bindingIds)
        {
            var releasedCount = 0;
            var nodeSetKey = BuildRobotNodesKey(robotId);
            var edgeSetKey = BuildRobotEdgesKey(robotId);
            var bindingsSetKey = BuildRobotBindingsKey(robotId);
            var bindingIdList = bindingIds
                .Where(id => !string.IsNullOrWhiteSpace(id))
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .ToList();
            var bindingResources = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

            foreach (var bindingId in bindingIdList)
            {
                var resourceKeys = await GetBindingResourceKeysStrictAsync(
                    robotId,
                    bindingId,
                    allowAlreadyReleased: true);
                if (resourceKeys.Count > 0)
                {
                    await ValidateBindingResourcesAsync(robotId, bindingId, resourceKeys);
                }

                bindingResources[bindingId] = resourceKeys;
            }

            foreach (var bindingId in bindingIdList)
            {
                var bindingIndexKey = BuildBindingIndexKey(robotId, bindingId);
                var resourceKeys = bindingResources[bindingId];

                foreach (var resourceKey in resourceKeys)
                {
                    var releaseResult = await ReleaseBindingFromResourceKeyAsync(resourceKey, robotId, bindingId);
                    if (releaseResult == BindingReleaseResult.ResourceDeleted)
                    {
                        releasedCount++;
                        if (resourceKey.StartsWith($"{_settings.Redis.KeyPrefixes.NodeLockPrefix}:", StringComparison.OrdinalIgnoreCase))
                        {
                            await RedisDb.SetRemoveAsync(nodeSetKey, resourceKey);
                        }
                        else if (resourceKey.StartsWith($"{_settings.Redis.KeyPrefixes.EdgeLockPrefix}:", StringComparison.OrdinalIgnoreCase))
                        {
                            await RedisDb.SetRemoveAsync(edgeSetKey, resourceKey);
                        }
                    }
                    else if (releaseResult == BindingReleaseResult.InvalidLegacyFormat)
                    {
                        throw new InvalidOperationException($"发现旧格式锁数据，无法按严格 binding 释放: {resourceKey}");
                    }
                }

                await RedisDb.KeyDeleteAsync(bindingIndexKey);
                await RedisDb.SetRemoveAsync(bindingsSetKey, bindingIndexKey);
            }

            if (await RedisDb.SetLengthAsync(bindingsSetKey) == 0)
            {
                await RedisDb.KeyDeleteAsync(bindingsSetKey);
            }

            return releasedCount;
        }

        public Task<int> RollbackBindingsAsync(
            string mapCode,
            Guid robotId,
            IEnumerable<string> bindingIds)
        {
            return ReleaseBindingsAsync(mapCode, robotId, bindingIds);
        }

        #endregion

        #region 内部模型

        private class LockInfo
        {
            public Guid RobotId { get; set; }
            public DateTime LockedAt { get; set; }
            public DateTime ExpiresAt { get; set; }
            public List<string> BindingIds { get; set; } = new();

            /// <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);
        }

        private sealed class BindingAcquireResult
        {
            public bool Success { get; set; }

            public bool HasReverseConflict { get; set; }

            public bool InvalidLegacyFormat { get; set; }

            public string? FailureReason { get; set; }

            public Guid? ConflictingRobotId { get; set; }
        }

        private enum BindingReleaseResult
        {
            NoChange = 0,
            BindingRemoved = 1,
            ResourceDeleted = 2,
            InvalidLegacyFormat = 3
        }

        #endregion

        #region 路口冲突检测辅助方法

        /// <summary>
        /// 检查节点是否被其他机器人占用
        /// @author zzy
        /// @date 2026-03-10
        /// </summary>
        public async Task<bool> IsNodeOccupiedByOtherAsync(string mapCode, string nodeCode, Guid myRobotId)
        {
            var key = BuildNodeKey(mapCode, nodeCode);
            var lockInfo = await GetLockInfoAsync(key);

            if (lockInfo == null)
                return false;

            // 检查是否被其他机器人占用
            return lockInfo.RobotId != myRobotId;
        }

        /// <summary>
        /// 检查边是否存在逆向冲突
        /// @author zzy
        /// @date 2026-03-10
        /// </summary>
        public async Task<bool> HasReverseConflictAsync(
            string mapCode,
            string edgeCode,
            string fromNodeCode,
            string toNodeCode,
            Guid myRobotId)
        {
            var reverseEdgeCode = ResolveReverseEdgeCode(mapCode, edgeCode, fromNodeCode, toNodeCode);
            if (string.IsNullOrEmpty(reverseEdgeCode))
            {
                return false;
            }

            // 检查逆向边是否被占用
            var reverseEdgeLockKey = BuildEdgeKey(mapCode, reverseEdgeCode);
            var lockInfo = await GetLockInfoAsync(reverseEdgeLockKey);

            if (lockInfo == null)
                return false;

            // 检查是否被其他机器人占用，且方向相反
            if (lockInfo.RobotId == myRobotId)
                return false;

            // 检查方向是否相反
            if (lockInfo.HasDirection)
            {
                var isReverse = lockInfo.FromNodeCode == toNodeCode && lockInfo.ToNodeCode == fromNodeCode;
                return isReverse;
            }

            return true;
        }

        /// <summary>
        /// 获取锁信息
        /// @author zzy
        /// @date 2026-03-10
        /// </summary>
        private async Task<LockInfo?> GetLockInfoAsync(string key)
        {
            var entries = await RedisDb.HashGetAllAsync(key);
            if (entries.Length == 0)
                return null;

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

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

            var lockInfo = new LockInfo { RobotId = robotId };

            if (dict.TryGetValue(LockFieldLockedAt, out var lockedAtStr) &&
                long.TryParse(lockedAtStr, out var lockedAtTicks))
            {
                lockInfo.LockedAt = new DateTime(lockedAtTicks, DateTimeKind.Local);
            }

            if (dict.TryGetValue(LockFieldExpiresAt, out var expiresAtStr) &&
                long.TryParse(expiresAtStr, out var expiresAtTicks))
            {
                lockInfo.ExpiresAt = new DateTime(expiresAtTicks, DateTimeKind.Local);
            }

            if (dict.TryGetValue(LockFieldFromNode, out var fromNode))
            {
                lockInfo.FromNodeCode = fromNode;
            }

            if (dict.TryGetValue(LockFieldToNode, out var toNode))
            {
                lockInfo.ToNodeCode = toNode;
            }

            if (dict.TryGetValue(LockFieldBindings, out var bindingsRaw) &&
                !string.IsNullOrWhiteSpace(bindingsRaw))
            {
                try
                {
                    lockInfo.BindingIds = JsonSerializer.Deserialize<List<string>>(bindingsRaw) ?? new List<string>();
                }
                catch (JsonException)
                {
                    lockInfo.BindingIds = new List<string>();
                }
            }

            return lockInfo;
        }

        /// <summary>
        /// 获取占用指定节点的机器人ID列表
        /// @author zzy
        /// @date 2026-03-10
        /// </summary>
        public async Task<List<Guid>> GetRobotsOccupyingNodeAsync(string mapCode, string nodeCode)
        {
            var key = BuildNodeKey(mapCode, nodeCode);
            var lockInfo = await GetLockInfoAsync(key);

            if (lockInfo == null)
                return new List<Guid>();

            return new List<Guid> { lockInfo.RobotId };
        }

        /// <summary>
        /// 获取占用指定边的机器人ID列表
        /// @author zzy
        /// @date 2026-03-10
        /// </summary>
        public async Task<List<Guid>> GetRobotsOccupyingEdgeAsync(string mapCode, string edgeCode)
        {
            var key = BuildEdgeKey(mapCode, edgeCode);
            var lockInfo = await GetLockInfoAsync(key);

            if (lockInfo == null)
                return new List<Guid>();

            return new List<Guid> { lockInfo.RobotId };
        }

        #endregion
    }
}