namespace Yw.WinFrmUI
{
    /// <summary>
    /// 
    /// </summary>
    public static class HydroModelInfoCheckExtensions
    {

        /// <summary>
        /// 校验
        /// </summary>
        public static HydroCheckResult Check(this Yw.Model.HydroModelInfo hydroInfo)
        {
            var result = new HydroCheckResult();
            if (hydroInfo == null)
            {
                result.Succeed = false;
                return result;
            }

            //验证水源
            var checkItemLackSource = new HydroCheckItem()
            {
                Mode = HydroCheckMode.Global,
                Type = HydroCheckType.LackSource,
                Code = string.Empty,
                Failed = false,
                Reason = "至少包含一座水库或水池（水箱）"
            };
            var allSourceList = hydroInfo.GetAllSources();
            result.Items.Add(checkItemLackSource);
            if (allSourceList == null || allSourceList.Count < 1)
            {
                checkItemLackSource.Failed = true;
            }

            //验证连接节点
            var checkItemLackJunction = new HydroCheckItem()
            {
                Mode = HydroCheckMode.Global,
                Type = HydroCheckType.LackJunction,
                Code = string.Empty,
                Failed = false,
                Reason = "至少包含一个连接节点"
            };
            result.Items.Add(checkItemLackJunction);
            var allJunctionList = hydroInfo.GetAllJunctions();
            if (allJunctionList == null || allJunctionList.Count < 1)
            {
                checkItemLackJunction.Failed = true;
            }

            //验证水泵
            var allPumpList = hydroInfo.Pumps;
            if (allPumpList == null)
            {
                allPumpList = new List<Model.HydroPumpInfo>();
            }
            var checkItemLackPump = new HydroCheckItem()
            {
                Mode = HydroCheckMode.Global,
                Type = HydroCheckType.LackPump,
                Code = string.Empty,
                Failed = false,
                Reason = "至少包含一台水泵"
            };
            result.Items.Add(checkItemLackPump);
            if (allPumpList.Count < 1)
            {
                checkItemLackPump.Failed = true;
            }

            //验证孤立节点
            var allNodeList = hydroInfo.GetAllNodes();
            var allLinkList = hydroInfo.GetAllLinks();
            foreach (var node in allNodeList)
            {
                var checkItemAloneNode = new HydroCheckItem()
                {
                    Mode = HydroCheckMode.Item,
                    Type = HydroCheckType.AloneNode,
                    Code = node.Code,
                    Failed = false,
                    Reason = "判断是否有管段连接"
                };
                result.Items.Add(checkItemAloneNode);
                if (!allLinkList.Exists(x => x.StartCode == node.Code || x.EndCode == node.Code))
                {
                    checkItemAloneNode.Failed = true;
                }
            }

            //验证管段异常连接
            foreach (var link in allLinkList)
            {
                var checkItemAbnormalLink = new HydroCheckItem()
                {
                    Mode = HydroCheckMode.Item,
                    Type = HydroCheckType.AbnormalLink,
                    Code = link.Code,
                    Failed = false,
                    Reason = "管段异常连接"
                };
                result.Items.Add(checkItemAbnormalLink);
                var startNode = allNodeList.Find(x => x.Code == link.StartCode);
                var endNode = allNodeList.Find(x => x.Code == link.EndCode);

                //孤立管段
                if (startNode == null && startNode == null)
                {
                    checkItemAbnormalLink.Failed = true;
                    checkItemAbnormalLink.Reason = "孤立管段";
                }
                else
                {
                    if (startNode == null)
                    {
                        checkItemAbnormalLink.Failed = true;
                        checkItemAbnormalLink.Reason = "缺少上游节点";
                    }
                    else if (endNode == null)
                    {
                        checkItemAbnormalLink.Failed = true;
                        checkItemAbnormalLink.Reason = "缺少下游节点";
                    }
                    else
                    {
                        if (startNode == endNode)
                        {
                            checkItemAbnormalLink.Failed = true;
                            checkItemAbnormalLink.Reason = "上下游节点相同";
                        }
                    }
                }
            }

            //验证水库
            //验证水池
            //验证水箱
            //验证水泵
            foreach (var pump in allPumpList)
            {
                //额定功率
                var checkItemRatedP = new HydroCheckItem()
                {
                    Mode = HydroCheckMode.Item,
                    Type = HydroCheckType.AbnormalProp,
                    Code = pump.Code,
                    Failed = false,
                    Reason = "判断水泵额定功率"
                };
                result.Items.Add(checkItemRatedP);
                if (pump.RatedP < 10)
                {
                    checkItemRatedP.Failed = true;
                    checkItemRatedP.Reason = "水泵额定功率设定错误";
                }

                //流量扬程曲线
                var checkItemCurveQH = new HydroCheckItem()
                {
                    Mode = HydroCheckMode.Item,
                    Type = HydroCheckType.AbnormalProp,
                    Code = pump.Code,
                    Failed = false,
                    Reason = "判断是否设置流量扬程曲线"
                };
                result.Items.Add(checkItemCurveQH);
                if (string.IsNullOrEmpty(pump.CurveQH))
                {
                    checkItemCurveQH.Failed = true;
                    checkItemCurveQH.Reason = "未设置流量扬程曲线";
                }
                else
                {
                    var curve = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQH);
                    if (curve == null)
                    {
                        checkItemCurveQH.Failed = true;
                        checkItemCurveQH.Reason = "流量扬程曲线设置错误";
                    }
                }
            }

            //验证管道
            var allPipeList = hydroInfo.Pipes;
            if (allPipeList == null)
            {
                allPipeList = new List<Model.HydroPipeInfo>();
            }
            foreach (var pipe in allPipeList)
            {
                //长度
                var checkItemLength = new HydroCheckItem()
                {
                    Mode = HydroCheckMode.Item,
                    Type = HydroCheckType.AbnormalProp,
                    Code = pipe.Code,
                    Failed = false,
                    Reason = "判断管道长度"
                };
                result.Items.Add(checkItemLength);
                if (pipe.Length <= 0)
                {
                    checkItemLength.Failed = true;
                    checkItemLength.Reason = "管道长度属性设置错误";
                }

                //直径
                var checkItemDiameter = new HydroCheckItem()
                {
                    Mode = HydroCheckMode.Item,
                    Type = HydroCheckType.AbnormalProp,
                    Code = pipe.Code,
                    Failed = false,
                    Reason = "判断管道直径"
                };
                result.Items.Add(checkItemDiameter);
                if (pipe.Diameter <= 10 || pipe.Diameter > 10000)
                {
                    checkItemDiameter.Failed = true;
                    checkItemDiameter.Reason = "管道直径区间（10,10000]";
                }

                //粗糙系数
                var checkItemRoughness = new HydroCheckItem()
                {
                    Mode = HydroCheckMode.Item,
                    Type = HydroCheckType.AbnormalProp,
                    Code = pipe.Code,
                    Failed = false,
                    Reason = "判断管道粗糙系数"
                };
                result.Items.Add(checkItemRoughness);
                if (pipe.Roughness <= 5 || pipe.Roughness > 10000)
                {
                    checkItemRoughness.Failed = true;
                    checkItemRoughness.Reason = "管道粗糙系数（5,10000]";
                }
            }

            if (result.Items.Exists(x => x.Failed))
            {
                result.Succeed = false;
            }

            return result;
        }




    }
}