namespace Yw.Epanet
{
    /// <summary>
    /// 管网路径分析拓展
    /// </summary>
    public static class NetworkAnalysePathExtensions
    {

        /// <summary>
        /// 遍历下游主要供水路径
        /// </summary>
        /// <param name="node">节点</param>
        /// <param name="allCalcuLinkDict">所有管段计算字典</param>
        /// <returns></returns>
        public static List<Link> TraverseMainDownStreamPath(this Node node, Dictionary<string, CalcuLink> allCalcuLinkDict)
        {
            if (node == null)
            {
                return default;
            }
            if (allCalcuLinkDict == null || allCalcuLinkDict.Count < 1)
            {
                return default;
            }

            var visited = new HashSet<Node>();
            var queue = new Queue<Node>();
            queue.Enqueue(node);

            var pathLinks = new List<Link>();
            while (queue.Count > 0)
            {
                var current = queue.Dequeue();
                if (visited.Contains(current))
                {
                    break;
                }
                visited.Add(current);
                if (current.Links != null && current.Links.Count > 0)
                {
                    var linkDict = new Dictionary<Link, CalcuLink>();
                    foreach (var link in current.Links)
                    {
                        var calcuLink = allCalcuLinkDict.GetValue(link.Id);
                        if (calcuLink != null)
                        {
                            if (link.StartNodeId == current.Id)
                            {
                                if (calcuLink.Flow > 0)
                                {
                                    linkDict.Add(link, calcuLink);
                                }
                            }
                            else if (link.EndNodeId == current.Id)
                            {
                                if (calcuLink.Flow < 0)
                                {
                                    linkDict.Add(link, calcuLink);
                                }
                            }
                        }
                    }
                    if (linkDict.Count > 0)
                    {
                        var linkKeyValue = linkDict.OrderBy(x => Math.Abs(x.Value.Flow)).LastOrDefault();
                        pathLinks.Add(linkKeyValue.Key);
                        var nextNode = linkKeyValue.Key.GetEndNode(linkKeyValue.Value);
                        if (nextNode != null)
                        {
                            queue.Enqueue(nextNode);
                        }
                    }
                }
            }

            return pathLinks;
        }

        /// <summary>
        /// 遍历下游主要供水路径
        /// </summary>
        /// <param name="node">节点</param>
        /// <param name="allCalcuLinkList">所有管段计算列表</param>
        /// <returns></returns>
        public static List<Link> TraverseMainDownStreamPath(this Node node, List<CalcuLink> allCalcuLinkList)
        {
            var dict = allCalcuLinkList?.ToDictionary(x => x.Id);
            return node.TraverseMainDownStreamPath(dict);
        }

        /// <summary>
        /// 遍历上游主要供水路径
        /// </summary>
        /// <param name="node">节点</param>
        /// <param name="allCalcuLinkDict">所有管段计算字典</param>
        /// <returns></returns>
        public static List<Link> TraverseMainUpStreamPath(this Node node, Dictionary<string, CalcuLink> allCalcuLinkDict)
        {
            if (node == null)
            {
                return default;
            }
            if (allCalcuLinkDict == null || allCalcuLinkDict.Count < 1)
            {
                return default;
            }

            var visited = new HashSet<Node>();
            var queue = new Queue<Node>();
            queue.Enqueue(node);

            var pathLinks = new List<Link>();
            while (queue.Count > 0)
            {
                var current = queue.Dequeue();
                if (visited.Contains(current))
                {
                    break;
                }
                visited.Add(current);
                if (current.Links != null && current.Links.Count > 0)
                {
                    var linkDict = new Dictionary<Link, CalcuLink>();
                    foreach (var link in current.Links)
                    {
                        var calcuLink = allCalcuLinkDict.GetValue(link.Id);
                        if (calcuLink != null)
                        {
                            if (link.StartNodeId == current.Id)
                            {
                                if (calcuLink.Flow < 0)
                                {
                                    linkDict.Add(link, calcuLink);
                                }
                            }
                            else if (link.EndNodeId == current.Id)
                            {
                                if (calcuLink.Flow > 0)
                                {
                                    linkDict.Add(link, calcuLink);
                                }
                            }
                        }
                    }
                    if (linkDict.Count > 0)
                    {
                        var linkKeyValue = linkDict.OrderBy(x => Math.Abs(x.Value.Flow)).LastOrDefault();
                        pathLinks.Add(linkKeyValue.Key);
                        var nextNode = linkKeyValue.Key.GetStartNode(linkKeyValue.Value);
                        if (nextNode != null)
                        {
                            queue.Enqueue(nextNode);
                        }
                    }
                }
            }

            return pathLinks;
        }

        /// <summary>
        /// 遍历上游主要供水路径
        /// </summary>
        /// <param name="node">节点</param>
        /// <param name="allCalcuLinkList">所有管段计算列表</param>
        /// <returns></returns>
        public static List<Link> TraverseMainUpStreamPath(this Node node, List<CalcuLink> allCalcuLinkList)
        {
            var dict = allCalcuLinkList?.ToDictionary(x => x.Id);
            return node.TraverseMainUpStreamPath(dict);
        }

        /// <summary>
        /// 遍历主要供水路径
        /// </summary>
        /// <param name="node">节点</param>
        /// <param name="allCalcuLinkDict">所有管段计算字典</param>
        /// <param name="direction">方向</param>
        /// <returns></returns>
        public static List<Link> TraverseMainStreamPath(this Node node, Dictionary<string, CalcuLink> allCalcuLinkDict, eTraverseDirection direction = eTraverseDirection.All)
        {
            if (node == null)
            {
                return default;
            }
            if (allCalcuLinkDict == null || allCalcuLinkDict.Count < 1)
            {
                return default;
            }
            List<Link> pathLinks = null;
            switch (direction)
            {
                case eTraverseDirection.Up:
                    {
                        pathLinks = TraverseMainUpStreamPath(node, allCalcuLinkDict);
                    }
                    break;
                case eTraverseDirection.Down:
                    {
                        pathLinks = TraverseMainDownStreamPath(node, allCalcuLinkDict);
                    }
                    break;
                case eTraverseDirection.All:
                    {
                        pathLinks = new List<Link>();
                        var pathUpLinks = TraverseMainUpStreamPath(node, allCalcuLinkDict);
                        if (pathUpLinks != null && pathUpLinks.Count > 0)
                        {
                            pathLinks.AddRange(pathUpLinks);
                        }
                        var pathDownLinks = TraverseMainDownStreamPath(node, allCalcuLinkDict);
                        if (pathDownLinks != null && pathDownLinks.Count > 0)
                        {
                            pathLinks.AddRange(pathDownLinks);
                        }
                    }
                    break;
                default: break;
            }
            return pathLinks;
        }

        /// <summary>
        /// 遍历主要供水路径
        /// </summary>
        /// <param name="node">节点</param>
        /// <param name="allCalcuLinkList">所有管段计算列表</param>
        /// <param name="direction">方向</param>
        /// <returns></returns>
        public static List<Link> TraverseMainStreamPath(this Node node, List<CalcuLink> allCalcuLinkList, eTraverseDirection direction = eTraverseDirection.All)
        {
            var dict = allCalcuLinkList?.ToDictionary(x => x.Id);
            return node.TraverseMainStreamPath(dict, direction);
        }

        /// <summary>
        /// 获取路径损失节点列表
        /// </summary>
        /// <param name="nw">管网</param>
        /// <param name="pathLinks">管段路径</param>
        /// <param name="calcuResult">计算结果</param>
        /// <returns></returns>
        public static List<PathLossNode> GetPathLossNodeList(this Network nw, List<Link> pathLinks, CalcuResult calcuResult)
        {
            #region 验证

            if (nw == null)
            {
                return default;
            }
            if (pathLinks == null || pathLinks.Count < 1)
            {
                return default;
            }
            if (calcuResult == null)
            {
                return default;
            }
            if (!calcuResult.Succeed)
            {
                return default;
            }
            var allCalcuNodeDict = calcuResult.GetNodeDict();
            if (allCalcuNodeDict == null || allCalcuNodeDict.Count < 1)
            {
                return default;
            }
            var allCalcuLinkDict = calcuResult.GetLinkDict();
            if (allCalcuLinkDict == null || allCalcuLinkDict.Count < 1)
            {
                return default;
            }

            #endregion

            double distance = 0;
            var allPathLossNodeList = new List<PathLossNode>();
            for (int i = 0; i < pathLinks.Count; i++)
            {
                var link = pathLinks[i];
                var calcuLink = allCalcuLinkDict.GetValue(link.Id);
                if (calcuLink == null)
                {
                    continue;
                }

                var startNode = link.GetStartNode(calcuLink);
                if (startNode == null)
                {
                    continue;
                }
                var startCalcuNode = allCalcuNodeDict.GetValue(startNode.Id);
                if (startCalcuNode == null)
                {
                    continue;
                }

                var startPathLossNode = new PathLossNode()
                {
                    Id = startNode.Id,
                    Elev = startNode.GetElev(),
                    Distance = distance,
                    Head = startCalcuNode.Head,
                    MinorLoss = startCalcuNode.MinorLoss
                };
                allPathLossNodeList.Add(startPathLossNode);

                if (link is Pipe pipe)
                {
                    distance += pipe.Length;
                }
                else if (link is Pump pump)
                {
                    distance += ConstParas.DefaultPumpLength;
                }
                else if (link is Valve)
                {
                    distance += ConstParas.DefaultValveLength;
                }

                if (i == pathLinks.Count - 1)
                {
                    var endNode = link.GetEndNode(calcuLink);
                    if (endNode == null)
                    {
                        continue;
                    }
                    var endCalcuNode = allCalcuNodeDict.GetValue(endNode.Id);
                    if (endCalcuNode == null)
                    {
                        continue;
                    }

                    var endPathLossNode = new PathLossNode()
                    {
                        Id = endNode.Id,
                        Elev = endNode.GetElev(),
                        Distance = distance,
                        Head = endCalcuNode.Head,
                        MinorLoss = endCalcuNode.MinorLoss
                    };
                    allPathLossNodeList.Add(endPathLossNode);
                }
            }
            return allPathLossNodeList;
        }














    }


}