zengzy / hhrcs_service · Files

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Rcs.Application.Services;
using Rcs.Application.Services.PathFind.Models;

namespace Rcs.Infrastructure.PathFinding.Services
{
    /// <summary>
    /// 地图映射服务实现 - 管理厂家地图与物理拓扑的映射关系
    /// @author zzy
    /// </summary>
    public class MapMappingService : IMapMappingService
    {
        private readonly ILogger<MapMappingService> _logger;
        private readonly IMapCacheService _mapCacheService;

        // 物理拓扑缓存 Key: TopologyId
        private readonly ConcurrentDictionary<Guid, PhysicalTopology> _topologyCache = new();

        // 地图到拓扑的映射 Key: MapId, Value: TopologyId
        private readonly ConcurrentDictionary<Guid, Guid> _mapToTopologyIndex = new();

        // 厂家节点到物理节点的映射 Key: (MapId, VendorNodeId), Value: PhysicalNodeId
        private readonly ConcurrentDictionary<(Guid MapId, Guid VendorNodeId), Guid> _vendorNodeToPhysicalIndex = new();

        // 厂家边到物理边的映射 Key: (MapId, VendorEdgeId), Value: PhysicalEdgeId
        private readonly ConcurrentDictionary<(Guid MapId, Guid VendorEdgeId), Guid> _vendorEdgeToPhysicalIndex = new();

        // 坐标变换缓存 Key: MapId
        private readonly ConcurrentDictionary<Guid, CoordinateTransform> _transformCache = new();

        // 合并拓扑缓存 Key: MapCode
        private readonly ConcurrentDictionary<string, MergedMapTopology> _mergedTopologyCache = new();

        public MapMappingService(
            ILogger<MapMappingService> logger,
            IMapCacheService mapCacheService)
        {
            _logger = logger;
            _mapCacheService = mapCacheService;
        }

        #region 按 MapCode 合并映射（核心功能）

        /// <summary>
        /// 初始化所有地图的合并映射
        /// 从Redis加载所有地图，按MapCode分组，对同组地图进行节点/边并集合并
        /// @author zzy
        /// </summary>
        public async Task<Dictionary<string, MergedMapTopology>> InitializeAllMappingsAsync()
        {
            var result = new Dictionary<string, MergedMapTopology>();

            try
            {
                // 获取所有地图并按MapCode分组
                var groupedMaps = await _mapCacheService.GetMapsGroupedByCodeAsync();

                _logger.LogInformation("开始初始化合并映射，共 {GroupCount} 个MapCode分组", groupedMaps.Count);

                foreach (var (mapCode, maps) in groupedMaps)
                {
                    if (string.IsNullOrEmpty(mapCode))
                    {
                        _logger.LogWarning("跳过空MapCode的地图，共 {Count} 张", maps.Count);
                        continue;
                    }

                    var merged = await MergeMapsByCodeAsync(mapCode, maps);
                    if (merged != null)
                    {
                        _mergedTopologyCache[mapCode] = merged;
                        result[mapCode] = merged;

                        _logger.LogInformation(
                            "合并完成: MapCode={MapCode}, 厂商地图数={VendorCount}, 合并节点数={NodeCount}, 合并边数={EdgeCount}",
                            mapCode, merged.VendorMaps.Count, merged.TotalNodeCount, merged.TotalEdgeCount);
                    }
                }

                _logger.LogInformation("所有地图合并映射初始化完成，共 {Count} 个MapCode", result.Count);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "初始化合并映射失败");
                throw;
            }

            return result;
        }

        /// <summary>
        /// 合并同一MapCode下的所有厂商地图
        /// @author zzy
        /// </summary>
        private Task<MergedMapTopology?> MergeMapsByCodeAsync(string mapCode, List<MapCacheData> maps)
        {
            if (maps == null || maps.Count == 0)
            {
                return Task.FromResult<MergedMapTopology?>(null);
            }

            var merged = new MergedMapTopology
            {
                MapCode = mapCode,
                MergedAt = DateTime.Now
            };

            // 用于构建逆向边映射
            var edgeCodeToReverseCode = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

            foreach (var map in maps)
            {
                // 记录厂商地图信息
                merged.VendorMaps.Add(new VendorMapInfo
                {
                    MapId = map.MapId,
                    MapCode = map.MapCode,
                    MapName = map.MapName,
                    Version = map.Version,
                    NodeCount = map.Nodes.Count(n => n.Active),
                    EdgeCount = map.Edges.Count(e => e.Active)
                });

                // 构建节点ID到NodeCode的映射（用于边的逆向查找）
                var nodeIdToCode = map.Nodes
                    .Where(n => n.Active)
                    .ToDictionary(n => n.NodeId, n => n.NodeCode);

                // 合并节点（并集）
                foreach (var node in map.Nodes.Where(n => n.Active))
                {
                    var nodeCodeKey = node.NodeCode.ToUpperInvariant();

                    if (!merged.Nodes.TryGetValue(nodeCodeKey, out var mergedNode))
                    {
                        // 新节点，创建合并节点
                        mergedNode = new MergedNode
                        {
                            NodeCode = node.NodeCode,
                            X = node.X,
                            Y = node.Y,
                            NodeType = node.Type
                        };
                        merged.Nodes[nodeCodeKey] = mergedNode;
                    }

                    // 添加厂商映射
                    mergedNode.VendorMappings.Add(new VendorNodeInfo
                    {
                        MapId = map.MapId,
                        MapName = map.MapName,
                        NodeId = node.NodeId,
                        NodeCode = node.NodeCode,
                        X = node.X,
                        Y = node.Y
                    });
                }

                // 合并边（并集）
                foreach (var edge in map.Edges.Where(e => e.Active))
                {
                    var edgeCodeKey = edge.EdgeCode.ToUpperInvariant();

                    // 获取起终点NodeCode
                    var fromNodeCode = nodeIdToCode.GetValueOrDefault(edge.FromNode, string.Empty);
                    var toNodeCode = nodeIdToCode.GetValueOrDefault(edge.ToNode, string.Empty);

                    if (!merged.Edges.TryGetValue(edgeCodeKey, out var mergedEdge))
                    {
                        // 新边，创建合并边
                        mergedEdge = new MergedEdge
                        {
                            EdgeCode = edge.EdgeCode,
                            FromNodeCode = fromNodeCode,
                            ToNodeCode = toNodeCode,
                            Length = edge.Length
                        };
                        merged.Edges[edgeCodeKey] = mergedEdge;
                    }

                    // 添加厂商映射
                    mergedEdge.VendorMappings.Add(new VendorEdgeInfo
                    {
                        MapId = map.MapId,
                        MapName = map.MapName,
                        EdgeId = edge.EdgeId,
                        EdgeCode = edge.EdgeCode,
                        FromNodeId = edge.FromNode,
                        ToNodeId = edge.ToNode,
                        Length = edge.Length,
                    });
                }
            }

            // 填充逆向边映射（根据起点/终点节点编码互换判断逆向边）
            foreach (var edge in merged.Edges.Values)
            {
                // 查找起点和终点互换的边作为逆向边
                var reverseEdge = merged.Edges.Values.FirstOrDefault(e =>
                    string.Equals(e.FromNodeCode, edge.ToNodeCode, StringComparison.OrdinalIgnoreCase) &&
                    string.Equals(e.ToNodeCode, edge.FromNodeCode, StringComparison.OrdinalIgnoreCase) &&
                    !string.Equals(e.EdgeCode, edge.EdgeCode, StringComparison.OrdinalIgnoreCase));

                if (reverseEdge != null)
                {
                    edge.ReverseEdgeCode = reverseEdge.EdgeCode;
                    merged.ReverseEdgeMap[edge.EdgeCode] = reverseEdge.EdgeCode;
                }
                else
                {
                    merged.ReverseEdgeMap[edge.EdgeCode] = null;
                }
            }

            // _logger.LogDebug(
            //     "地图合并详情: MapCode={MapCode}, 厂商数={VendorCount}, 节点并集={NodeCount}, 边并集={EdgeCount}, 逆向边对数={ReverseCount}",
            //     mapCode, maps.Count, merged.Nodes.Count, merged.Edges.Count, merged.ReverseEdgeMap.Count(kv => kv.Value != null));

            return Task.FromResult<MergedMapTopology?>(merged);
        }

        /// <summary>
        /// 获取指定MapCode的合并拓扑
        /// @author zzy
        /// </summary>
        public Task<MergedMapTopology?> GetMergedTopologyAsync(string mapCode)
        {
            if (string.IsNullOrEmpty(mapCode))
            {
                return Task.FromResult<MergedMapTopology?>(null);
            }

            _mergedTopologyCache.TryGetValue(mapCode, out var merged);
            return Task.FromResult<MergedMapTopology?>(merged);
        }

        /// <summary>
        /// 获取所有已合并的MapCode列表
        /// @author zzy
        /// </summary>
        public Task<IEnumerable<string>> GetAllMergedMapCodesAsync()
        {
            return Task.FromResult<IEnumerable<string>>(_mergedTopologyCache.Keys.ToList());
        }

        /// <summary>
        /// 刷新指定MapCode的合并映射（地图更新后调用）
        /// @author zzy
        /// </summary>
        public async Task<MergedMapTopology?> RefreshMergedMappingAsync(string mapCode)
        {
            if (string.IsNullOrEmpty(mapCode))
            {
                return null;
            }

            try
            {
                // 获取该MapCode下的所有地图
                var groupedMaps = await _mapCacheService.GetMapsGroupedByCodeAsync();

                if (!groupedMaps.TryGetValue(mapCode, out var maps) || maps.Count == 0)
                {
                    // 该MapCode下没有地图了，移除缓存
                    _mergedTopologyCache.TryRemove(mapCode, out _);
                    _logger.LogInformation("MapCode {MapCode} 下没有地图，已移除合并缓存", mapCode);
                    return null;
                }

                var merged = await MergeMapsByCodeAsync(mapCode, maps);
                if (merged != null)
                {
                    _mergedTopologyCache[mapCode] = merged;
                    _logger.LogInformation(
                        "刷新合并映射成功: MapCode={MapCode}, 节点数={NodeCount}, 边数={EdgeCount}",
                        mapCode, merged.TotalNodeCount, merged.TotalEdgeCount);
                }

                return merged;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "刷新合并映射失败: MapCode={MapCode}", mapCode);
                throw;
            }
        }

        /// <summary>
        /// 根据 NodeCode 获取该节点在各厂家地图中的映射
        /// @author zzy
        /// </summary>
        public Task<List<VendorNodeInfo>> GetVendorNodesByCodeAsync(string mapCode, string nodeCode)
        {
            var result = new List<VendorNodeInfo>();

            if (string.IsNullOrEmpty(mapCode) || string.IsNullOrEmpty(nodeCode))
            {
                return Task.FromResult(result);
            }

            if (_mergedTopologyCache.TryGetValue(mapCode, out var merged))
            {
                var nodeCodeKey = nodeCode.ToUpperInvariant();
                if (merged.Nodes.TryGetValue(nodeCodeKey, out var mergedNode))
                {
                    result.AddRange(mergedNode.VendorMappings);
                }
            }

            return Task.FromResult(result);
        }

        /// <summary>
        /// 根据 EdgeCode 获取该边在各厂家地图中的映射
        /// @author zzy
        /// </summary>
        public Task<List<VendorEdgeInfo>> GetVendorEdgesByCodeAsync(string mapCode, string edgeCode)
        {
            var result = new List<VendorEdgeInfo>();

            if (string.IsNullOrEmpty(mapCode) || string.IsNullOrEmpty(edgeCode))
            {
                return Task.FromResult(result);
            }

            if (_mergedTopologyCache.TryGetValue(mapCode, out var merged))
            {
                var edgeCodeKey = edgeCode.ToUpperInvariant();
                if (merged.Edges.TryGetValue(edgeCodeKey, out var mergedEdge))
                {
                    result.AddRange(mergedEdge.VendorMappings);
                }
            }

            return Task.FromResult(result);
        }

        #endregion

        #region 物理拓扑管理

        /// <summary>
        /// 创建物理拓扑（基于第一张地图）
        /// @author zzy
        /// </summary>
        public async Task<Guid> CreatePhysicalTopologyAsync(Guid baseMapId, string topologyName)
        {
            var mapData = await _mapCacheService.GetMapAsync(baseMapId);
            if (mapData == null)
            {
                throw new InvalidOperationException($"找不到地图: {baseMapId}");
            }

            var topology = new PhysicalTopology
            {
                TopologyId = Guid.NewGuid(),
                TopologyName = topologyName,
                CreatedAt = DateTime.Now,
                UpdatedAt = DateTime.Now
            };

            // 基于第一张地图创建物理拓扑，其坐标系直接作为物理坐标系
            var identityTransform = new CoordinateTransform(); // 单位变换

            // 创建物理节点
            foreach (var node in mapData.Nodes.Where(n => n.Active))
            {
                var physicalNode = new PhysicalNode
                {
                    PhysicalNodeId = Guid.NewGuid(),
                    PhysicalNodeCode = $"P_{node.NodeCode}",
                    PhysicalX = node.X,
                    PhysicalY = node.Y,
                    AllowWait = true,
                    AllowRotate = node.AllowRotate
                };

                // 添加基准地图的映射
                physicalNode.VendorMappings[baseMapId] = new VendorNodeMapping
                {
                    MapId = baseMapId,
                    MapCode = mapData.MapCode,
                    MapVersion = mapData.Version,
                    VendorNodeId = node.NodeId,
                    VendorNodeCode = node.NodeCode,
                    VendorX = node.X,
                    VendorY = node.Y,
                    MatchConfidence = 1.0,
                    IsManualMapping = false
                };

                topology.Nodes[physicalNode.PhysicalNodeId] = physicalNode;

                // 建立索引
                _vendorNodeToPhysicalIndex[(baseMapId, node.NodeId)] = physicalNode.PhysicalNodeId;
            }

            // 创建物理边
            foreach (var edge in mapData.Edges.Where(e => e.Active))
            {
                // 查找对应的物理节点
                if (!_vendorNodeToPhysicalIndex.TryGetValue((baseMapId, edge.FromNode), out var fromPhysicalId)) continue;
                if (!_vendorNodeToPhysicalIndex.TryGetValue((baseMapId, edge.ToNode), out var toPhysicalId)) continue;

                var physicalEdge = new PhysicalEdge
                {
                    PhysicalEdgeId = Guid.NewGuid(),
                    PhysicalEdgeCode = $"P_{edge.EdgeCode}",
                    FromPhysicalNodeId = fromPhysicalId,
                    ToPhysicalNodeId = toPhysicalId,
                    Length = edge.Length,
                    IsBidirectional = false // 默认单向，根据边属性判断
                };

                // 添加基准地图的映射
                physicalEdge.VendorMappings[baseMapId] = new VendorEdgeMapping
                {
                    MapId = baseMapId,
                    MapCode = mapData.MapCode,
                    VendorEdgeId = edge.EdgeId,
                    VendorEdgeCode = edge.EdgeCode,
                    VendorFromNodeId = edge.FromNode,
                    VendorToNodeId = edge.ToNode,
                    MatchConfidence = 1.0
                };

                topology.Edges[physicalEdge.PhysicalEdgeId] = physicalEdge;

                // 建立节点的出边/入边关系
                if (topology.Nodes.TryGetValue(fromPhysicalId, out var fromNode))
                    fromNode.OutEdges.Add(physicalEdge);
                if (topology.Nodes.TryGetValue(toPhysicalId, out var toNode))
                    toNode.InEdges.Add(physicalEdge);

                // 建立索引
                _vendorEdgeToPhysicalIndex[(baseMapId, edge.EdgeId)] = physicalEdge.PhysicalEdgeId;
            }

            // 添加关联地图信息
            topology.LinkedMaps.Add(new LinkedVendorMap
            {
                MapId = baseMapId,
                MapCode = mapData.MapCode,
                MapVersion = mapData.Version,
                Manufacturer = "Base", // 基准地图
                Transform = identityTransform,
                MappedNodeCount = topology.Nodes.Count,
                MappedEdgeCount = topology.Edges.Count,
                UnmappedNodeCount = 0,
                LinkedAt = DateTime.Now
            });

            // 缓存
            _topologyCache[topology.TopologyId] = topology;
            _mapToTopologyIndex[baseMapId] = topology.TopologyId;
            _transformCache[baseMapId] = identityTransform;

            _logger.LogInformation("创建物理拓扑成功: TopologyId={TopologyId}, Name={Name}, Nodes={NodeCount}, Edges={EdgeCount}",
                topology.TopologyId, topologyName, topology.Nodes.Count, topology.Edges.Count);

            return topology.TopologyId;
        }

        /// <summary>
        /// 获取物理拓扑
        /// @author zzy
        /// </summary>
        public Task<PhysicalTopologyDto?> GetPhysicalTopologyAsync(Guid topologyId)
        {
            if (!_topologyCache.TryGetValue(topologyId, out var topology))
            {
                return Task.FromResult<PhysicalTopologyDto?>(null);
            }

            var dto = new PhysicalTopologyDto
            {
                TopologyId = topology.TopologyId,
                TopologyName = topology.TopologyName,
                NodeCount = topology.Nodes.Count,
                EdgeCount = topology.Edges.Count,
                LinkedMaps = topology.LinkedMaps.Select(m => new LinkedVendorMapDto
                {
                    MapId = m.MapId,
                    MapCode = m.MapCode,
                    MapVersion = m.MapVersion,
                    Manufacturer = m.Manufacturer,
                    MappedNodeCount = m.MappedNodeCount,
                    UnmappedNodeCount = m.UnmappedNodeCount,
                    LinkedAt = m.LinkedAt
                }).ToList()
            };

            return Task.FromResult<PhysicalTopologyDto?>(dto);
        }

        /// <summary>
        /// 获取地图所属的物理拓扑ID
        /// @author zzy
        /// </summary>
        public Task<Guid?> GetTopologyIdByMapAsync(Guid mapId)
        {
            if (_mapToTopologyIndex.TryGetValue(mapId, out var topologyId))
            {
                return Task.FromResult<Guid?>(topologyId);
            }
            return Task.FromResult<Guid?>(null);
        }

        #endregion

        #region 地图关联与自动映射

        /// <summary>
        /// 将厂家地图关联到物理拓扑（自动映射）
        /// 同一地图编码下，NodeCode相同的节点视为同一物理位置
        /// @author zzy
        /// </summary>
        public async Task<AutoMappingResult> LinkMapToTopologyAsync(Guid topologyId, Guid mapId, MapMappingConfig? config = null)
        {
            config ??= new MapMappingConfig();

            if (!_topologyCache.TryGetValue(topologyId, out var topology))
            {
                return new AutoMappingResult
                {
                    Success = false,
                    ErrorMessage = $"找不到物理拓扑: {topologyId}"
                };
            }

            var mapData = await _mapCacheService.GetMapAsync(mapId);
            if (mapData == null)
            {
                return new AutoMappingResult
                {
                    Success = false,
                    ErrorMessage = $"找不到地图: {mapId}"
                };
            }

            // 检查是否已关联
            if (topology.LinkedMaps.Any(m => m.MapId == mapId))
            {
                return new AutoMappingResult
                {
                    Success = false,
                    ErrorMessage = $"地图 {mapId} 已关联到拓扑"
                };
            }

            var result = new AutoMappingResult { Success = true };

            // 构建物理节点的NodeCode索引（用于快速查找）
            var physicalNodeByCode = BuildPhysicalNodeCodeIndex(topology, config.NodeCodeCaseSensitive);

            // 坐标变换（基于匹配节点估算）
            var transform = new CoordinateTransform();

            // 进行节点自动匹配（按NodeCode）
            var vendorNodes = mapData.Nodes.Where(n => n.Active).ToList();
            var unmappedVendorNodes = new List<MapNodeCache>();
            var matchedPairsForTransform = new List<(MapNodeCache Vendor, PhysicalNode Physical)>();

            foreach (var vendorNode in vendorNodes)
            {
                var nodeCodeKey = config.NodeCodeCaseSensitive
                    ? vendorNode.NodeCode
                    : vendorNode.NodeCode.ToUpperInvariant();

                // 按NodeCode查找匹配的物理节点
                if (physicalNodeByCode.TryGetValue(nodeCodeKey, out var matchedPhysicalNode))
                {
                    // NodeCode匹配成功
                    matchedPhysicalNode.VendorMappings[mapId] = new VendorNodeMapping
                    {
                        MapId = mapId,
                        MapCode = mapData.MapCode,
                        MapVersion = mapData.Version,
                        VendorNodeId = vendorNode.NodeId,
                        VendorNodeCode = vendorNode.NodeCode,
                        VendorX = vendorNode.X,
                        VendorY = vendorNode.Y,
                        MatchConfidence = 1.0, // NodeCode精确匹配，置信度100%
                        IsManualMapping = false
                    };

                    _vendorNodeToPhysicalIndex[(mapId, vendorNode.NodeId)] = matchedPhysicalNode.PhysicalNodeId;
                    result.MappedNodeCount++;

                    // 记录用于坐标变换估算
                    matchedPairsForTransform.Add((vendorNode, matchedPhysicalNode));
                }
                else
                {
                    // 未找到匹配的NodeCode
                    unmappedVendorNodes.Add(vendorNode);
                }
            }

            // 基于匹配的节点估算坐标变换参数
            if (matchedPairsForTransform.Count >= 2)
            {
                transform = EstimateCoordinateTransformByNodeCode(matchedPairsForTransform);
            }

            result.EstimatedTransform = new CoordinateTransformDto
            {
                OffsetX = transform.OffsetX,
                OffsetY = transform.OffsetY,
                RotationAngle = transform.RotationAngle,
                Scale = transform.Scale
            };

            // 为未匹配的节点创建新的物理节点（如果配置允许）
            if (config.AutoCreateUnmatchedNodes)
            {
                foreach (var vendorNode in unmappedVendorNodes)
                {
                    var (physicalX, physicalY) = transform.ToPhysical(vendorNode.X, vendorNode.Y);

                    var newPhysicalNode = new PhysicalNode
                    {
                        PhysicalNodeId = Guid.NewGuid(),
                        PhysicalNodeCode = vendorNode.NodeCode, // 直接使用NodeCode作为物理节点编码
                        PhysicalX = physicalX,
                        PhysicalY = physicalY,
                        AllowWait = true,
                        AllowRotate = vendorNode.AllowRotate
                    };

                    newPhysicalNode.VendorMappings[mapId] = new VendorNodeMapping
                    {
                        MapId = mapId,
                        MapCode = mapData.MapCode,
                        MapVersion = mapData.Version,
                        VendorNodeId = vendorNode.NodeId,
                        VendorNodeCode = vendorNode.NodeCode,
                        VendorX = vendorNode.X,
                        VendorY = vendorNode.Y,
                        MatchConfidence = 1.0,
                        IsManualMapping = false
                    };

                    topology.Nodes[newPhysicalNode.PhysicalNodeId] = newPhysicalNode;
                    _vendorNodeToPhysicalIndex[(mapId, vendorNode.NodeId)] = newPhysicalNode.PhysicalNodeId;

                    // 更新索引
                    var codeKey = config.NodeCodeCaseSensitive
                        ? vendorNode.NodeCode
                        : vendorNode.NodeCode.ToUpperInvariant();
                    physicalNodeByCode[codeKey] = newPhysicalNode;

                    result.UnmappedNodeCount++;
                }
            }
            else
            {
                // 记录未匹配的节点供人工处理
                foreach (var vendorNode in unmappedVendorNodes)
                {
                    result.LowConfidenceMappings.Add(new LowConfidenceMapping
                    {
                        VendorNodeId = vendorNode.NodeId,
                        VendorNodeCode = vendorNode.NodeCode,
                        SuggestedPhysicalNodeId = null,
                        Confidence = 0,
                        Distance = 0,
                        Reason = $"NodeCode '{vendorNode.NodeCode}' 在物理拓扑中不存在"
                    });
                }
                result.UnmappedNodeCount = unmappedVendorNodes.Count;
            }

            // 进行边自动匹配
            var vendorEdges = mapData.Edges.Where(e => e.Active).ToList();

            foreach (var vendorEdge in vendorEdges)
            {
                // 获取对应的物理节点
                if (!_vendorNodeToPhysicalIndex.TryGetValue((mapId, vendorEdge.FromNode), out var fromPhysicalId)) continue;
                if (!_vendorNodeToPhysicalIndex.TryGetValue((mapId, vendorEdge.ToNode), out var toPhysicalId)) continue;

                // 查找是否已有对应的物理边（按起终点物理节点匹配）
                var existingEdge = topology.Edges.Values.FirstOrDefault(e =>
                    e.FromPhysicalNodeId == fromPhysicalId && e.ToPhysicalNodeId == toPhysicalId);

                if (existingEdge != null)
                {
                    // 边已存在，添加映射
                    existingEdge.VendorMappings[mapId] = new VendorEdgeMapping
                    {
                        MapId = mapId,
                        MapCode = mapData.MapCode,
                        VendorEdgeId = vendorEdge.EdgeId,
                        VendorEdgeCode = vendorEdge.EdgeCode,
                        VendorFromNodeId = vendorEdge.FromNode,
                        VendorToNodeId = vendorEdge.ToNode,
                        MatchConfidence = 1.0
                    };

                    _vendorEdgeToPhysicalIndex[(mapId, vendorEdge.EdgeId)] = existingEdge.PhysicalEdgeId;
                    result.MappedEdgeCount++;
                }
                else
                {
                    // 创建新的物理边
                    var newPhysicalEdge = new PhysicalEdge
                    {
                        PhysicalEdgeId = Guid.NewGuid(),
                        PhysicalEdgeCode = vendorEdge.EdgeCode, // 直接使用EdgeCode
                        FromPhysicalNodeId = fromPhysicalId,
                        ToPhysicalNodeId = toPhysicalId,
                        Length = vendorEdge.Length,
                        IsBidirectional = false
                    };

                    newPhysicalEdge.VendorMappings[mapId] = new VendorEdgeMapping
                    {
                        MapId = mapId,
                        MapCode = mapData.MapCode,
                        VendorEdgeId = vendorEdge.EdgeId,
                        VendorEdgeCode = vendorEdge.EdgeCode,
                        VendorFromNodeId = vendorEdge.FromNode,
                        VendorToNodeId = vendorEdge.ToNode,
                        MatchConfidence = 1.0
                    };

                    topology.Edges[newPhysicalEdge.PhysicalEdgeId] = newPhysicalEdge;

                    // 建立节点关系
                    if (topology.Nodes.TryGetValue(fromPhysicalId, out var fromNode))
                        fromNode.OutEdges.Add(newPhysicalEdge);
                    if (topology.Nodes.TryGetValue(toPhysicalId, out var toNode))
                        toNode.InEdges.Add(newPhysicalEdge);

                    _vendorEdgeToPhysicalIndex[(mapId, vendorEdge.EdgeId)] = newPhysicalEdge.PhysicalEdgeId;
                    result.UnmappedEdgeCount++;
                }
            }

            // 更新拓扑信息
            topology.LinkedMaps.Add(new LinkedVendorMap
            {
                MapId = mapId,
                MapCode = mapData.MapCode,
                MapVersion = mapData.Version,
                Manufacturer = ExtractManufacturer(mapData),
                Transform = transform,
                MappedNodeCount = result.MappedNodeCount,
                MappedEdgeCount = result.MappedEdgeCount,
                UnmappedNodeCount = result.UnmappedNodeCount,
                LinkedAt = DateTime.Now
            });

            topology.UpdatedAt = DateTime.Now;
            _mapToTopologyIndex[mapId] = topologyId;
            _transformCache[mapId] = transform;

            _logger.LogInformation(
                "关联地图成功(按NodeCode匹配): MapId={MapId}, MapCode={MapCode}, MappedNodes={MappedNodes}, NewNodes={NewNodes}, MappedEdges={MappedEdges}",
                mapId, mapData.MapCode, result.MappedNodeCount, result.UnmappedNodeCount, result.MappedEdgeCount);

            return result;
        }

        /// <summary>
        /// 构建物理节点的NodeCode索引
        /// @author zzy
        /// </summary>
        private Dictionary<string, PhysicalNode> BuildPhysicalNodeCodeIndex(PhysicalTopology topology, bool caseSensitive)
        {
            var index = new Dictionary<string, PhysicalNode>(
                caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);

            foreach (var node in topology.Nodes.Values)
            {
                // 使用物理节点编码（去掉前缀"P_"如果有的话）
                var code = node.PhysicalNodeCode;
                if (code.StartsWith("P_"))
                {
                    code = code.Substring(2);
                }

                if (!index.ContainsKey(code))
                {
                    index[code] = node;
                }
            }

            return index;
        }

        /// <summary>
        /// 基于匹配的节点估算坐标变换参数
        /// @author zzy
        /// </summary>
        private CoordinateTransform EstimateCoordinateTransformByNodeCode(List<(MapNodeCache Vendor, PhysicalNode Physical)> matchedPairs)
        {
            if (matchedPairs.Count < 2)
            {
                return new CoordinateTransform();
            }

            // 计算平均偏移
            var avgOffsetX = matchedPairs.Average(p => p.Physical.PhysicalX - p.Vendor.X);
            var avgOffsetY = matchedPairs.Average(p => p.Physical.PhysicalY - p.Vendor.Y);

            _logger.LogInformation("坐标变换估算(基于NodeCode匹配): OffsetX={OffsetX:F3}, OffsetY={OffsetY:F3}, 基于 {Count} 个匹配节点",
                avgOffsetX, avgOffsetY, matchedPairs.Count);

            return new CoordinateTransform
            {
                OffsetX = avgOffsetX,
                OffsetY = avgOffsetY,
                RotationAngle = 0,
                Scale = 1.0
            };
        }

        /// <summary>
        /// 从地图数据中提取制造商标识
        /// @author zzy
        /// </summary>
        private static string ExtractManufacturer(MapCacheData mapData)
        {
            // 尝试从MapCode中提取制造商（假设格式为 "Manufacturer_xxx" 或直接使用MapCode）
            if (!string.IsNullOrEmpty(mapData.MapCode))
            {
                var parts = mapData.MapCode.Split('_');
                if (parts.Length > 1)
                {
                    return parts[0];
                }
                return mapData.MapCode;
            }
            return "Unknown";
        }

        /// <summary>
        /// 手动确认/修正节点映射
        /// @author zzy
        /// </summary>
        public Task<bool> ConfirmNodeMappingAsync(Guid topologyId, Guid vendorNodeId, Guid mapId, Guid physicalNodeId)
        {
            if (!_topologyCache.TryGetValue(topologyId, out var topology))
            {
                return Task.FromResult(false);
            }

            if (!topology.Nodes.TryGetValue(physicalNodeId, out var physicalNode))
            {
                return Task.FromResult(false);
            }

            // 更新映射（如果已存在则覆盖）
            if (physicalNode.VendorMappings.TryGetValue(mapId, out var existingMapping))
            {
                existingMapping.IsManualMapping = true;
                existingMapping.MatchConfidence = 1.0;
            }

            // 更新索引
            _vendorNodeToPhysicalIndex[(mapId, vendorNodeId)] = physicalNodeId;

            _logger.LogInformation("手动确认节点映射: VendorNode={VendorNodeId} -> PhysicalNode={PhysicalNodeId}",
                vendorNodeId, physicalNodeId);

            return Task.FromResult(true);
        }

        /// <summary>
        /// 添加新的物理节点（针对某厂家独有的节点）
        /// @author zzy
        /// </summary>
        public async Task<Guid> AddPhysicalNodeAsync(Guid topologyId, Guid vendorNodeId, Guid mapId)
        {
            if (!_topologyCache.TryGetValue(topologyId, out var topology))
            {
                throw new InvalidOperationException($"找不到物理拓扑: {topologyId}");
            }

            var mapData = await _mapCacheService.GetMapAsync(mapId);
            if (mapData == null)
            {
                throw new InvalidOperationException($"找不到地图: {mapId}");
            }

            var vendorNode = mapData.Nodes.FirstOrDefault(n => n.NodeId == vendorNodeId);
            if (vendorNode == null)
            {
                throw new InvalidOperationException($"找不到厂家节点: {vendorNodeId}");
            }

            // 获取坐标变换
            _transformCache.TryGetValue(mapId, out var transform);
            transform ??= new CoordinateTransform();

            var (physicalX, physicalY) = transform.ToPhysical(vendorNode.X, vendorNode.Y);

            var newPhysicalNode = new PhysicalNode
            {
                PhysicalNodeId = Guid.NewGuid(),
                PhysicalNodeCode = $"P_{mapData.MapCode}_{vendorNode.NodeCode}",
                PhysicalX = physicalX,
                PhysicalY = physicalY,
                AllowWait = true,
                AllowRotate = vendorNode.AllowRotate
            };

            newPhysicalNode.VendorMappings[mapId] = new VendorNodeMapping
            {
                MapId = mapId,
                MapCode = mapData.MapCode,
                MapVersion = mapData.Version,
                VendorNodeId = vendorNodeId,
                VendorNodeCode = vendorNode.NodeCode,
                VendorX = vendorNode.X,
                VendorY = vendorNode.Y,
                MatchConfidence = 1.0,
                IsManualMapping = true
            };

            topology.Nodes[newPhysicalNode.PhysicalNodeId] = newPhysicalNode;
            _vendorNodeToPhysicalIndex[(mapId, vendorNodeId)] = newPhysicalNode.PhysicalNodeId;

            return newPhysicalNode.PhysicalNodeId;
        }

        /// <summary>
        /// 刷新映射
        /// @author zzy
        /// </summary>
        public Task<AutoMappingResult> RefreshMappingAsync(Guid topologyId, Guid mapId)
        {
            // 先移除旧映射，再重新关联
            // 实际实现需要更复杂的逻辑来保留手动映射
            throw new NotImplementedException("RefreshMapping 尚未实现");
        }

        #endregion

        #region 映射查询

        /// <summary>
        /// 根据厂家节点ID获取物理节点ID
        /// @author zzy
        /// </summary>
        public Task<Guid?> GetPhysicalNodeIdAsync(Guid vendorNodeId, Guid mapId)
        {
            if (_vendorNodeToPhysicalIndex.TryGetValue((mapId, vendorNodeId), out var physicalNodeId))
            {
                return Task.FromResult<Guid?>(physicalNodeId);
            }
            return Task.FromResult<Guid?>(null);
        }

        /// <summary>
        /// 根据厂家边ID获取物理边ID
        /// @author zzy
        /// </summary>
        public Task<Guid?> GetPhysicalEdgeIdAsync(Guid vendorEdgeId, Guid mapId)
        {
            if (_vendorEdgeToPhysicalIndex.TryGetValue((mapId, vendorEdgeId), out var physicalEdgeId))
            {
                return Task.FromResult<Guid?>(physicalEdgeId);
            }
            return Task.FromResult<Guid?>(null);
        }

        /// <summary>
        /// 批量获取物理节点ID
        /// @author zzy
        /// </summary>
        public Task<Dictionary<Guid, Guid>> GetPhysicalNodeIdsAsync(IEnumerable<Guid> vendorNodeIds, Guid mapId)
        {
            var result = new Dictionary<Guid, Guid>();
            foreach (var vendorNodeId in vendorNodeIds)
            {
                if (_vendorNodeToPhysicalIndex.TryGetValue((mapId, vendorNodeId), out var physicalNodeId))
                {
                    result[vendorNodeId] = physicalNodeId;
                }
            }
            return Task.FromResult(result);
        }

        /// <summary>
        /// 批量获取物理边ID
        /// @author zzy
        /// </summary>
        public Task<Dictionary<Guid, Guid>> GetPhysicalEdgeIdsAsync(IEnumerable<Guid> vendorEdgeIds, Guid mapId)
        {
            var result = new Dictionary<Guid, Guid>();
            foreach (var vendorEdgeId in vendorEdgeIds)
            {
                if (_vendorEdgeToPhysicalIndex.TryGetValue((mapId, vendorEdgeId), out var physicalEdgeId))
                {
                    result[vendorEdgeId] = physicalEdgeId;
                }
            }
            return Task.FromResult(result);
        }

        /// <summary>
        /// 根据物理节点ID获取所有厂家映射
        /// @author zzy
        /// </summary>
        public Task<List<VendorNodeMappingDto>> GetVendorMappingsByPhysicalNodeAsync(Guid physicalNodeId)
        {
            var result = new List<VendorNodeMappingDto>();

            foreach (var topology in _topologyCache.Values)
            {
                if (topology.Nodes.TryGetValue(physicalNodeId, out var physicalNode))
                {
                    foreach (var mapping in physicalNode.VendorMappings.Values)
                    {
                        result.Add(new VendorNodeMappingDto
                        {
                            MapId = mapping.MapId,
                            MapCode = mapping.MapCode,
                            VendorNodeId = mapping.VendorNodeId,
                            VendorNodeCode = mapping.VendorNodeCode,
                            VendorX = mapping.VendorX,
                            VendorY = mapping.VendorY
                        });
                    }
                    break;
                }
            }

            return Task.FromResult(result);
        }

        /// <summary>
        /// 根据物理节点ID获取指定地图的厂家节点ID
        /// @author zzy
        /// </summary>
        public Task<Guid?> GetVendorNodeIdAsync(Guid physicalNodeId, Guid mapId)
        {
            foreach (var topology in _topologyCache.Values)
            {
                if (topology.Nodes.TryGetValue(physicalNodeId, out var physicalNode))
                {
                    if (physicalNode.VendorMappings.TryGetValue(mapId, out var mapping))
                    {
                        return Task.FromResult<Guid?>(mapping.VendorNodeId);
                    }
                    break;
                }
            }
            return Task.FromResult<Guid?>(null);
        }

        #endregion

        #region 坐标转换

        /// <summary>
        /// 将厂家坐标转换为物理坐标
        /// @author zzy
        /// </summary>
        public Task<(double X, double Y)?> ToPhysicalCoordinateAsync(double vendorX, double vendorY, Guid mapId)
        {
            if (_transformCache.TryGetValue(mapId, out var transform))
            {
                var result = transform.ToPhysical(vendorX, vendorY);
                return Task.FromResult<(double X, double Y)?>(result);
            }
            return Task.FromResult<(double X, double Y)?>(null);
        }

        /// <summary>
        /// 将物理坐标转换为厂家坐标
        /// @author zzy
        /// </summary>
        public Task<(double X, double Y)?> ToVendorCoordinateAsync(double physicalX, double physicalY, Guid mapId)
        {
            if (_transformCache.TryGetValue(mapId, out var transform))
            {
                var result = transform.ToVendor(physicalX, physicalY);
                return Task.FromResult<(double X, double Y)?>(result);
            }
            return Task.FromResult<(double X, double Y)?>(null);
        }

        #endregion
    }
}