zengzy / hhrcs_service · Files

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Rcs.Application.Services
{
    /// <summary>
    /// 地图映射配置
    /// @author zzy
    /// </summary>
    public class MapMappingConfig
    {
        /// <summary>
        /// 匹配模式
        /// </summary>
        public MapMatchingMode MatchingMode { get; set; } = MapMatchingMode.ByNodeCode;

        /// <summary>
        /// 是否允许一对多映射（一个物理节点映射多个厂家节点）
        /// </summary>
        public bool AllowOneToMany { get; set; } = true;

        /// <summary>
        /// 节点编码匹配是否区分大小写
        /// </summary>
        public bool NodeCodeCaseSensitive { get; set; } = false;

        /// <summary>
        /// 是否自动创建未匹配节点为新物理节点
        /// </summary>
        public bool AutoCreateUnmatchedNodes { get; set; } = true;
    }

    /// <summary>
    /// 地图匹配模式
    /// @author zzy
    /// </summary>
    public enum MapMatchingMode
    {
        /// <summary>
        /// 按节点编码匹配（推荐）：同一地图编码下，NodeCode相同的节点视为同一物理位置
        /// </summary>
        ByNodeCode = 1,

        /// <summary>
        /// 按坐标proximity匹配：在容差范围内的节点视为同一物理位置
        /// </summary>
        ByCoordinate = 2
    }

    /// <summary>
    /// 自动映射结果
    /// @author zzy
    /// </summary>
    public class AutoMappingResult
    {
        /// <summary>
        /// 是否成功
        /// </summary>
        public bool Success { get; set; }

        /// <summary>
        /// 错误信息
        /// </summary>
        public string? ErrorMessage { get; set; }

        /// <summary>
        /// 成功映射的节点数
        /// </summary>
        public int MappedNodeCount { get; set; }

        /// <summary>
        /// 成功映射的边数
        /// </summary>
        public int MappedEdgeCount { get; set; }

        /// <summary>
        /// 未映射的节点数（新地图独有的节点）
        /// </summary>
        public int UnmappedNodeCount { get; set; }

        /// <summary>
        /// 未映射的边数
        /// </summary>
        public int UnmappedEdgeCount { get; set; }

        /// <summary>
        /// 估算的坐标变换参数
        /// </summary>
        public CoordinateTransformDto? EstimatedTransform { get; set; }

        /// <summary>
        /// 低置信度映射列表（需要人工确认）
        /// </summary>
        public List<LowConfidenceMapping> LowConfidenceMappings { get; set; } = new();
    }

    /// <summary>
    /// 坐标变换参数DTO
    /// @author zzy
    /// </summary>
    public class CoordinateTransformDto
    {
        public double OffsetX { get; set; }
        public double OffsetY { get; set; }
        public double RotationAngle { get; set; }
        public double Scale { get; set; } = 1.0;
    }

    /// <summary>
    /// 低置信度映射（需要人工确认）
    /// @author zzy
    /// </summary>
    public class LowConfidenceMapping
    {
        /// <summary>
        /// 厂家节点ID
        /// </summary>
        public Guid VendorNodeId { get; set; }

        /// <summary>
        /// 厂家节点编码
        /// </summary>
        public string VendorNodeCode { get; set; } = string.Empty;

        /// <summary>
        /// 建议映射的物理节点ID
        /// </summary>
        public Guid? SuggestedPhysicalNodeId { get; set; }

        /// <summary>
        /// 匹配置信度
        /// </summary>
        public double Confidence { get; set; }

        /// <summary>
        /// 距离（米）
        /// </summary>
        public double Distance { get; set; }

        /// <summary>
        /// 原因说明
        /// </summary>
        public string Reason { get; set; } = string.Empty;
    }

    /// <summary>
    /// 地图映射服务接口 - 管理厂家地图与物理拓扑的映射关系
    /// 支持按 MapCode 分组，对同一物理环境的多厂商地图进行节点/边并集合并
    /// @author zzy
    /// </summary>
    public interface IMapMappingService
    {
        #region 按 MapCode 合并映射（核心功能）

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

        /// <summary>
        /// 获取指定MapCode的合并拓扑
        /// @author zzy
        /// </summary>
        Task<MergedMapTopology?> GetMergedTopologyAsync(string mapCode);

        /// <summary>
        /// 获取所有已合并的MapCode列表
        /// @author zzy
        /// </summary>
        Task<IEnumerable<string>> GetAllMergedMapCodesAsync();

        /// <summary>
        /// 刷新指定MapCode的合并映射（地图更新后调用）
        /// @author zzy
        /// </summary>
        Task<MergedMapTopology?> RefreshMergedMappingAsync(string mapCode);

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

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

        #endregion

        #region 物理拓扑管理（保留兼容）

        /// <summary>
        /// 创建物理拓扑（基于第一张地图）
        /// </summary>
        /// <param name="baseMapId">基准地图ID（第一张地图，其坐标系作为物理坐标系）</param>
        /// <param name="topologyName">拓扑名称</param>
        /// <returns>创建的拓扑ID</returns>
        Task<Guid> CreatePhysicalTopologyAsync(Guid baseMapId, string topologyName);

        /// <summary>
        /// 获取物理拓扑
        /// </summary>
        Task<PhysicalTopologyDto?> GetPhysicalTopologyAsync(Guid topologyId);

        /// <summary>
        /// 获取地图所属的物理拓扑ID
        /// </summary>
        Task<Guid?> GetTopologyIdByMapAsync(Guid mapId);

        #endregion

        #region 地图关联与自动映射（保留兼容）

        /// <summary>
        /// 将厂家地图关联到物理拓扑（自动映射）
        /// </summary>
        /// <param name="topologyId">物理拓扑ID</param>
        /// <param name="mapId">要关联的厂家地图ID</param>
        /// <param name="config">映射配置（可选）</param>
        /// <returns>自动映射结果</returns>
        Task<AutoMappingResult> LinkMapToTopologyAsync(Guid topologyId, Guid mapId, MapMappingConfig? config = null);

        /// <summary>
        /// 手动确认/修正节点映射
        /// </summary>
        Task<bool> ConfirmNodeMappingAsync(Guid topologyId, Guid vendorNodeId, Guid mapId, Guid physicalNodeId);

        /// <summary>
        /// 添加新的物理节点（针对某厂家独有的节点）
        /// </summary>
        Task<Guid> AddPhysicalNodeAsync(Guid topologyId, Guid vendorNodeId, Guid mapId);

        /// <summary>
        /// 刷新映射（地图更新后重新映射）
        /// </summary>
        Task<AutoMappingResult> RefreshMappingAsync(Guid topologyId, Guid mapId);

        #endregion

        #region 映射查询

        /// <summary>
        /// 根据厂家节点ID获取物理节点ID
        /// </summary>
        Task<Guid?> GetPhysicalNodeIdAsync(Guid vendorNodeId, Guid mapId);

        /// <summary>
        /// 根据厂家边ID获取物理边ID
        /// </summary>
        Task<Guid?> GetPhysicalEdgeIdAsync(Guid vendorEdgeId, Guid mapId);

        /// <summary>
        /// 批量获取物理节点ID
        /// </summary>
        Task<Dictionary<Guid, Guid>> GetPhysicalNodeIdsAsync(IEnumerable<Guid> vendorNodeIds, Guid mapId);

        /// <summary>
        /// 批量获取物理边ID
        /// </summary>
        Task<Dictionary<Guid, Guid>> GetPhysicalEdgeIdsAsync(IEnumerable<Guid> vendorEdgeIds, Guid mapId);

        /// <summary>
        /// 根据物理节点ID获取所有厂家映射
        /// </summary>
        Task<List<VendorNodeMappingDto>> GetVendorMappingsByPhysicalNodeAsync(Guid physicalNodeId);

        /// <summary>
        /// 根据物理节点ID获取指定地图的厂家节点ID
        /// </summary>
        Task<Guid?> GetVendorNodeIdAsync(Guid physicalNodeId, Guid mapId);

        #endregion

        #region 坐标转换

        /// <summary>
        /// 将厂家坐标转换为物理坐标
        /// </summary>
        Task<(double X, double Y)?> ToPhysicalCoordinateAsync(double vendorX, double vendorY, Guid mapId);

        /// <summary>
        /// 将物理坐标转换为厂家坐标
        /// </summary>
        Task<(double X, double Y)?> ToVendorCoordinateAsync(double physicalX, double physicalY, Guid mapId);

        #endregion
    }

    /// <summary>
    /// 物理拓扑DTO
    /// @author zzy
    /// </summary>
    public class PhysicalTopologyDto
    {
        public Guid TopologyId { get; set; }
        public string TopologyName { get; set; } = string.Empty;
        public int NodeCount { get; set; }
        public int EdgeCount { get; set; }
        public List<LinkedVendorMapDto> LinkedMaps { get; set; } = new();
    }

    /// <summary>
    /// 关联地图DTO
    /// @author zzy
    /// </summary>
    public class LinkedVendorMapDto
    {
        public Guid MapId { get; set; }
        public string MapCode { get; set; } = string.Empty;
        public string MapVersion { get; set; } = string.Empty;
        public string Manufacturer { get; set; } = string.Empty;
        public int MappedNodeCount { get; set; }
        public int UnmappedNodeCount { get; set; }
        public DateTime LinkedAt { get; set; }
    }

    /// <summary>
    /// 厂家节点映射DTO
    /// @author zzy
    /// </summary>
    public class VendorNodeMappingDto
    {
        public Guid MapId { get; set; }
        public string MapCode { get; set; } = string.Empty;
        public Guid VendorNodeId { get; set; }
        public string VendorNodeCode { get; set; } = string.Empty;
        public double VendorX { get; set; }
        public double VendorY { get; set; }
    }

    #region 合并映射模型

    /// <summary>
    /// 合并后的地图拓扑（按MapCode分组的所有厂商地图合并结果）
    /// 节点/边取并集，用于统一锁管理
    /// @author zzy
    /// </summary>
    public class MergedMapTopology
    {
        /// <summary>
        /// 地图编码（物理环境标识）
        /// </summary>
        public string MapCode { get; set; } = string.Empty;

        /// <summary>
        /// 参与合并的厂商地图列表
        /// </summary>
        public List<VendorMapInfo> VendorMaps { get; set; } = new();

        /// <summary>
        /// 合并后的所有节点（按NodeCode索引）
        /// Key: NodeCode, Value: 合并节点信息
        /// </summary>
        public Dictionary<string, MergedNode> Nodes { get; set; } = new();

        /// <summary>
        /// 合并后的所有边（按EdgeCode索引）
        /// Key: EdgeCode, Value: 合并边信息
        /// </summary>
        public Dictionary<string, MergedEdge> Edges { get; set; } = new();

        /// <summary>
        /// 逆向边映射（用于双向互斥）
        /// Key: EdgeCode, Value: ReverseEdgeCode（null表示单行道）
        /// </summary>
        public Dictionary<string, string?> ReverseEdgeMap { get; set; } = new();

        /// <summary>
        /// 合并时间
        /// </summary>
        public DateTime MergedAt { get; set; }

        /// <summary>
        /// 总节点数（并集）
        /// </summary>
        public int TotalNodeCount => Nodes.Count;

        /// <summary>
        /// 总边数（并集）
        /// </summary>
        public int TotalEdgeCount => Edges.Count;
    }

    /// <summary>
    /// 厂商地图基础信息
    /// @author zzy
    /// </summary>
    public class VendorMapInfo
    {
        public Guid MapId { get; set; }
        public string MapCode { get; set; } = string.Empty;
        public string MapName { get; set; } = string.Empty;
        public string Version { get; set; } = string.Empty;
        public int NodeCount { get; set; }
        public int EdgeCount { get; set; }
    }

    /// <summary>
    /// 合并后的节点信息
    /// @author zzy
    /// </summary>
    public class MergedNode
    {
        /// <summary>
        /// 节点编码（统一标识）
        /// </summary>
        public string NodeCode { get; set; } = string.Empty;

        /// <summary>
        /// 代表性坐标（取第一个厂商的坐标作为参考）
        /// </summary>
        public double X { get; set; }
        public double Y { get; set; }

        /// <summary>
        /// 节点类型
        /// </summary>
        public int NodeType { get; set; }

        /// <summary>
        /// 该节点在各厂商地图中的映射
        /// </summary>
        public List<VendorNodeInfo> VendorMappings { get; set; } = new();
    }

    /// <summary>
    /// 厂商节点信息
    /// @author zzy
    /// </summary>
    public class VendorNodeInfo
    {
        public Guid MapId { get; set; }
        public string MapName { get; set; } = string.Empty;
        public Guid NodeId { get; set; }
        public string NodeCode { get; set; } = string.Empty;
        public double X { get; set; }
        public double Y { get; set; }
    }

    /// <summary>
    /// 合并后的边信息
    /// @author zzy
    /// </summary>
    public class MergedEdge
    {
        /// <summary>
        /// 边编码（统一标识）
        /// </summary>
        public string EdgeCode { get; set; } = string.Empty;

        /// <summary>
        /// 起点节点编码
        /// </summary>
        public string FromNodeCode { get; set; } = string.Empty;

        /// <summary>
        /// 终点节点编码
        /// </summary>
        public string ToNodeCode { get; set; } = string.Empty;

        /// <summary>
        /// 逆向边编码（null表示单行道）
        /// </summary>
        public string? ReverseEdgeCode { get; set; }

        /// <summary>
        /// 边长度（取第一个厂商的长度作为参考）
        /// </summary>
        public double Length { get; set; }

        /// <summary>
        /// 该边在各厂商地图中的映射
        /// </summary>
        public List<VendorEdgeInfo> VendorMappings { get; set; } = new();
    }

    /// <summary>
    /// 厂商边信息
    /// @author zzy
    /// </summary>
    public class VendorEdgeInfo
    {
        public Guid MapId { get; set; }
        public string MapName { get; set; } = string.Empty;
        public Guid EdgeId { get; set; }
        public string EdgeCode { get; set; } = string.Empty;
        public Guid FromNodeId { get; set; }
        public Guid ToNodeId { get; set; }
        public double Length { get; set; }
        public Guid? ReverseEdgeId { get; set; }
    }

    #endregion
}