using DevExpress.Pdf.ContentGeneration.Fonts;
using NPOI.SS.Formula.Functions;
using SqlSugar;
using System.Diagnostics.Metrics;
using Yw.EPAnet;
using Yw.Hydro;
using Yw.Model;
namespace Yw.WinFrmUI
{
    /// <summary>
    /// 
    /// </summary>
    public static class HydroCalcuResultExtensions
    {
        /// <summary>
        /// 计算
        /// </summary>
        public static HydroCalcuResult Calcu
            (
                this Yw.Model.HydroModelInfo hydroInfo,
                string calcuMode = Yw.EPAnet.CalcuMode.MinorLoss,
                bool isHead = false,
                List<Yw.Vmo.HydroEvaluationVmo> allEvaluationList = null
            )
        {
            var network = hydroInfo.ToNetwork();
            if (network == null)
            {
                return default;
            }
            var calcuResult = network.Calcu(calcuMode);
            if (calcuResult == null)
            {
                return default;
            }
            return hydroInfo.GetCalcuResult(calcuResult, isHead, allEvaluationList);
        }

        /// <summary>
        /// 获取计算结果
        /// </summary>
        public static HydroCalcuResult GetCalcuResult
            (
                this Yw.Model.HydroModelInfo hydroInfo,
                Yw.EPAnet.CalcuResult calcuResult,
                bool isHead = false,
                List<Yw.Vmo.HydroEvaluationVmo> allEvaluationList = null
            )
        {
            if (hydroInfo == null)
            {
                return default;
            }
            if (calcuResult == null)
            {
                return default;
            }

            var allNodeList = hydroInfo.GetAllNodes();
            var allLinkList = hydroInfo.GetAllLinks();

            var hydroCalcuResult = new HydroCalcuResult(calcuResult);
            var allCalcuResultVisualDict = hydroCalcuResult.GetVisualDict();

            #region 评估

            //局部损失
            var allMinorLossEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.MinorLoss).ToList();
            //压差
            var allPressDiffEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.PressDiff).ToList();
            //千米沿程损失
            var allFrictionLossKmEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.FrictionLossKm).ToList();
            //运行流量
            var allFlowRunEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.FlowRun).ToList();
            //压力
            var allPressEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.Press).ToList();

            #endregion

            #region 水库

            var allReservoirList = hydroInfo.Reservoirs;
            if (allReservoirList != null && allReservoirList.Count > 0)
            {
                foreach (var reservoir in allReservoirList)
                {
                    var calcuReservoirResult = allCalcuResultVisualDict?.GetValue(reservoir.Code) as HydroCalcuNodeResult;
                    if (calcuReservoirResult != null)
                    {
                        var calcuReservoirNewResult = new HydroCalcuReservoirResult(calcuReservoirResult);
                        calcuReservoirNewResult.CalcuL = calcuReservoirResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuReservoirResult);
                        hydroCalcuResult.NodeList.Add(calcuReservoirNewResult);
                    }
                }
            }

            #endregion

            #region 水池

            var allTankList = hydroInfo.Tanks;
            if (allTankList != null && allTankList.Count > 0)
            {
                foreach (var tank in allTankList)
                {
                    var calcuTankResult = allCalcuResultVisualDict?.GetValue(tank.Code) as HydroCalcuNodeResult;
                    if (calcuTankResult != null)
                    {
                        var calcuTankNewResult = new HydroCalcuTankResult(calcuTankResult);
                        calcuTankNewResult.CalcuL = calcuTankResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuTankResult);
                        hydroCalcuResult.NodeList.Add(calcuTankNewResult);
                    }
                }
            }

            #endregion

            #region 水箱

            var allWaterboxList = hydroInfo.Waterboxs;
            if (allWaterboxList != null && allWaterboxList.Count > 0)
            {
                foreach (var waterbox in allWaterboxList)
                {
                    var calcuWaterboxResult = allCalcuResultVisualDict?.GetValue(waterbox.Code) as HydroCalcuNodeResult;
                    if (calcuWaterboxResult != null)
                    {
                        var calcuWaterboxNewResult = new HydroCalcuWaterboxResult(calcuWaterboxResult);
                        calcuWaterboxNewResult.CalcuL = calcuWaterboxResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuWaterboxResult);
                        hydroCalcuResult.NodeList.Add(calcuWaterboxNewResult);
                    }
                }
            }

            #endregion

            #region 连接节点

            var allJunctionList = hydroInfo.Junctions;
            if (allJunctionList != null && allJunctionList.Count > 0)
            {
                foreach (var junction in allJunctionList)
                {
                    var calcuJunctionResult = allCalcuResultVisualDict?.GetValue(junction.Code) as HydroCalcuNodeResult;
                    if (calcuJunctionResult != null)
                    {
                        var calcuJunctionNewResult = new HydroCalcuJunctionResult(calcuJunctionResult);
                        calcuJunctionNewResult.CalcuPr = isHead ? calcuJunctionResult.CalcuHead : calcuJunctionResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuJunctionResult);
                        hydroCalcuResult.NodeList.Add(calcuJunctionNewResult);
                    }
                }
            }

            #endregion

            #region 闷头

            var allBluntheadList = hydroInfo.Bluntheads;
            if (allBluntheadList != null && allBluntheadList.Count > 0)
            {
                foreach (var blunthead in allBluntheadList)
                {
                    var calcuBluntheadResult = allCalcuResultVisualDict?.GetValue(blunthead.Code) as HydroCalcuNodeResult;
                    if (calcuBluntheadResult != null)
                    {
                        var calcuBluntheadNewResult = new HydroCalcuBluntheadResult(calcuBluntheadResult);
                        calcuBluntheadNewResult.CalcuPr = isHead ? calcuBluntheadResult.CalcuHead : calcuBluntheadResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuBluntheadResult);
                        hydroCalcuResult.NodeList.Add(calcuBluntheadNewResult);
                    }
                }
            }

            #endregion

            #region 弯头

            var allElbowList = hydroInfo.Elbows;
            if (allElbowList != null && allElbowList.Count > 0)
            {
                var allElbowMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Elbow).ToList();
                foreach (var elbow in allElbowList)
                {
                    var calcuElbowResult = allCalcuResultVisualDict?.GetValue(elbow.Code) as HydroCalcuNodeResult;
                    if (calcuElbowResult != null)
                    {
                        var calcuElbowNewResult = new HydroCalcuElbowResult(calcuElbowResult);
                        calcuElbowNewResult.CalcuPr = isHead ? calcuElbowResult.CalcuHead : calcuElbowResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuElbowResult);
                        hydroCalcuResult.NodeList.Add(calcuElbowNewResult);
                        if (calcuElbowNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allElbowMinorLossEvaluationList != null && allElbowMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var elbowMinorLossEvaluation in allElbowMinorLossEvaluationList)
                                {
                                    if (elbowMinorLossEvaluation.IsMeet(calcuElbowNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = elbow.Code,
                                            Message = $"[{elbow.Name}]{elbowMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 三通

            var allThreelinkList = hydroInfo.Threelinks;
            if (allThreelinkList != null && allThreelinkList.Count > 0)
            {
                var allTreelinkMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Threelink).ToList();
                foreach (var threelink in allThreelinkList)
                {
                    var calcuThreelinkResult = allCalcuResultVisualDict?.GetValue(threelink.Code) as HydroCalcuNodeResult;
                    if (calcuThreelinkResult != null)
                    {
                        var calcuThreelinkNewResult = new HydroCalcuThreelinkResult(calcuThreelinkResult);
                        calcuThreelinkNewResult.CalcuPr = isHead ? calcuThreelinkResult.CalcuHead : calcuThreelinkResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuThreelinkResult);
                        hydroCalcuResult.NodeList.Add(calcuThreelinkNewResult);
                        if (calcuThreelinkNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allTreelinkMinorLossEvaluationList != null && allTreelinkMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var threelinkMinorLossEvaluation in allTreelinkMinorLossEvaluationList)
                                {
                                    if (threelinkMinorLossEvaluation.IsMeet(calcuThreelinkNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = threelink.Code,
                                            Message = $"[{threelink.Name}]{threelinkMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 四通

            var allFourlinkList = hydroInfo.Fourlinks;
            if (allFourlinkList != null && allFourlinkList.Count > 0)
            {
                var allFourlinkMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Fourlink).ToList();
                foreach (var fourlink in allFourlinkList)
                {
                    var calcuFourlinkResult = allCalcuResultVisualDict?.GetValue(fourlink.Code) as HydroCalcuNodeResult;
                    if (calcuFourlinkResult != null)
                    {
                        var calcuFourlinkNewResult = new HydroCalcuFourlinkResult(calcuFourlinkResult);
                        calcuFourlinkNewResult.CalcuPr = isHead ? calcuFourlinkResult.CalcuHead : calcuFourlinkResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuFourlinkResult);
                        hydroCalcuResult.NodeList.Add(calcuFourlinkNewResult);
                        if (calcuFourlinkNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allFourlinkMinorLossEvaluationList != null && allFourlinkMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var fourlinkMinorLossEvaluation in allFourlinkMinorLossEvaluationList)
                                {
                                    if (fourlinkMinorLossEvaluation.IsMeet(calcuFourlinkNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = fourlink.Code,
                                            Message = $"[{fourlink.Name}]{fourlinkMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 消火栓

            var allHydrantList = hydroInfo.Hydrants;
            if (allHydrantList != null && allHydrantList.Count > 0)
            {
                var allHydrantMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Hydrant).ToList();
                foreach (var hydrant in allHydrantList)
                {
                    var calcuHydrantResult = allCalcuResultVisualDict?.GetValue(hydrant.Code) as HydroCalcuNodeResult;
                    if (calcuHydrantResult != null)
                    {
                        var calcuHydrantNewResult = new HydroCalcuHydrantResult(calcuHydrantResult);
                        calcuHydrantNewResult.CalcuPr = isHead ? calcuHydrantResult.CalcuHead : calcuHydrantResult.CalcuPress;

                        var linkHydrantList = allLinkList?.Where(x => x.StartCode == hydrant.Code || x.EndCode == hydrant.Code).ToList();
                        if (linkHydrantList != null && linkHydrantList.Count > 0)
                        {
                            foreach (var linkHydrant in linkHydrantList)
                            {
                                var calcuLinkHydrantResult = allCalcuResultVisualDict?.GetValue(linkHydrant.Code) as HydroCalcuLinkResult;
                                if (calcuLinkHydrantResult != null)
                                {
                                    if (calcuLinkHydrantResult.CalcuFlow.HasValue)
                                    {
                                        calcuHydrantNewResult.CalcuQ = Math.Abs(calcuLinkHydrantResult.CalcuFlow.Value);
                                        break;
                                    }
                                }
                            }
                        }

                        hydroCalcuResult.NodeList.Remove(calcuHydrantResult);
                        hydroCalcuResult.NodeList.Add(calcuHydrantNewResult);

                        if (calcuHydrantNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allHydrantMinorLossEvaluationList != null && allHydrantMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var hydrantMinorLossEvaluation in allHydrantMinorLossEvaluationList)
                                {
                                    if (hydrantMinorLossEvaluation.IsMeet(calcuHydrantNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = hydrant.Code,
                                            Message = $"[{hydrant.Name}]{hydrantMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 喷头

            var allNozzleList = hydroInfo.Nozzles;
            if (allNozzleList != null && allNozzleList.Count > 0)
            {
                var allNozzleMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Nozzle).ToList();
                foreach (var nozzle in allNozzleList)
                {
                    var calcuNozzleResult = allCalcuResultVisualDict?.GetValue(nozzle.Code) as HydroCalcuNodeResult;
                    if (calcuNozzleResult != null)
                    {
                        var calcuNozzleNewResult = new HydroCalcuNozzleResult(calcuNozzleResult);
                        calcuNozzleNewResult.CalcuPr = isHead ? calcuNozzleResult.CalcuHead : calcuNozzleResult.CalcuPress;

                        var linkNozzleList = allLinkList?.Where(x => x.StartCode == nozzle.Code || x.EndCode == nozzle.Code).ToList();
                        if (linkNozzleList != null && linkNozzleList.Count > 0)
                        {
                            foreach (var linkNozzle in linkNozzleList)
                            {
                                var calcuLinkNozzleResult = allCalcuResultVisualDict?.GetValue(linkNozzle.Code) as HydroCalcuLinkResult;
                                if (calcuLinkNozzleResult != null)
                                {
                                    if (calcuLinkNozzleResult.CalcuFlow.HasValue)
                                    {
                                        calcuNozzleNewResult.CalcuQ = Math.Abs(calcuLinkNozzleResult.CalcuFlow.Value);
                                        break;
                                    }
                                }
                            }
                        }

                        hydroCalcuResult.NodeList.Remove(calcuNozzleResult);
                        hydroCalcuResult.NodeList.Add(calcuNozzleNewResult);

                        if (calcuNozzleNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allNozzleMinorLossEvaluationList != null && allNozzleMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var nozzleMinorLossEvaluation in allNozzleMinorLossEvaluationList)
                                {
                                    if (nozzleMinorLossEvaluation.IsMeet(calcuNozzleNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = nozzle.Code,
                                            Message = $"[{nozzle.Name}]{nozzleMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 冷却塔

            var allCoolingList = hydroInfo.Coolings;
            if (allCoolingList != null && allCoolingList.Count > 0)
            {
                var allCoolingMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Cooling).ToList();
                var allCoolingPressDiffEvaluationList = allPressDiffEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Cooling).ToList();
                foreach (var cooling in allCoolingList)
                {
                    var calcuCoolingResult = allCalcuResultVisualDict?.GetValue(cooling.Code) as HydroCalcuNodeResult;
                    if (calcuCoolingResult != null)
                    {
                        var calcuCoolingNewResult = new HydroCalcuCoolingResult(calcuCoolingResult);
                        calcuCoolingNewResult.CalcuPr = isHead ? calcuCoolingResult.CalcuHead : calcuCoolingResult.CalcuPress;

                        var linkCoolingList = allLinkList?.Where(x => x.StartCode == cooling.Code || x.EndCode == cooling.Code).ToList();
                        if (linkCoolingList != null && linkCoolingList.Count > 0)
                        {
                            foreach (var linkCooling in linkCoolingList)
                            {
                                var calcuLinkCoolingResult = allCalcuResultVisualDict?.GetValue(linkCooling.Code) as HydroCalcuLinkResult;
                                if (calcuLinkCoolingResult != null)
                                {
                                    if (calcuLinkCoolingResult.CalcuFlow.HasValue)
                                    {
                                        calcuCoolingNewResult.CalcuQ = Math.Abs(calcuLinkCoolingResult.CalcuFlow.Value);
                                        break;
                                    }
                                }
                            }
                        }

                        hydroCalcuResult.NodeList.Remove(calcuCoolingResult);
                        hydroCalcuResult.NodeList.Add(calcuCoolingNewResult);
                        if (calcuCoolingNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allCoolingMinorLossEvaluationList != null && allCoolingMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var coolingMinorLossEvaluation in allCoolingMinorLossEvaluationList)
                                {
                                    if (coolingMinorLossEvaluation.IsMeet(calcuCoolingNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = cooling.Code,
                                            Message = $"[{cooling.Name}]{coolingMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                        if (calcuCoolingNewResult.CalcuPress.HasValue)
                        {
                            if (allCoolingPressDiffEvaluationList != null && allCoolingPressDiffEvaluationList.Count > 0)
                            {
                                var coolingPressDiff = calcuCoolingNewResult.CalcuPress.Value - cooling.LowerLimit;
                                foreach (var coolingPressDiffEvaluation in allCoolingPressDiffEvaluationList)
                                {
                                    if (coolingPressDiffEvaluation.IsMeet(coolingPressDiff))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = cooling.Code,
                                            Message = $"[{cooling.Name}]{coolingPressDiffEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 水表

            var allMeterList = hydroInfo.Meters;
            if (allMeterList != null && allMeterList.Count > 0)
            {
                var allMeterMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Meter).ToList();
                foreach (var meter in allMeterList)
                {
                    var calcuMeterResult = allCalcuResultVisualDict?.GetValue(meter.Code) as HydroCalcuNodeResult;
                    if (calcuMeterResult != null)
                    {
                        var calcuMeterNewResult = new HydroCalcuMeterResult(calcuMeterResult);
                        calcuMeterNewResult.CalcuPr = isHead ? calcuMeterResult.CalcuHead : calcuMeterResult.CalcuPress;

                        var linkMeterList = allLinkList?.Where(x => x.StartCode == meter.Code || x.EndCode == meter.Code).ToList();
                        if (linkMeterList != null && linkMeterList.Count > 0)
                        {
                            foreach (var linkMeter in linkMeterList)
                            {
                                var calcuLinkMeterResult = allCalcuResultVisualDict?.GetValue(linkMeter.Code) as HydroCalcuLinkResult;
                                if (calcuLinkMeterResult != null)
                                {
                                    if (calcuLinkMeterResult.CalcuFlow.HasValue)
                                    {
                                        calcuMeterNewResult.CalcuQ = Math.Abs(calcuLinkMeterResult.CalcuFlow.Value);
                                        break;
                                    }
                                }
                            }
                        }

                        hydroCalcuResult.NodeList.Remove(calcuMeterResult);
                        hydroCalcuResult.NodeList.Add(calcuMeterNewResult);
                        if (calcuMeterNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allMeterMinorLossEvaluationList != null && allMeterMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var meterMinorLossEvaluation in allMeterMinorLossEvaluationList)
                                {
                                    if (meterMinorLossEvaluation.IsMeet(calcuMeterNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = meter.Code,
                                            Message = $"[{meter.Name}]{meterMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 流量计

            var allFlowmeterList = hydroInfo.Flowmeters;
            if (allFlowmeterList != null && allFlowmeterList.Count > 0)
            {
                var allFlowmeterMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Flowmeter).ToList();
                foreach (var flowmeter in allFlowmeterList)
                {
                    var calcuFlowmeterResult = allCalcuResultVisualDict?.GetValue(flowmeter.Code) as HydroCalcuNodeResult;
                    if (calcuFlowmeterResult != null)
                    {
                        var calcuFlowmeterNewResult = new HydroCalcuFlowmeterResult(calcuFlowmeterResult);
                        calcuFlowmeterNewResult.CalcuPr = isHead ? calcuFlowmeterResult.CalcuHead : calcuFlowmeterResult.CalcuPress;

                        var linkFlowmeterList = allLinkList?.Where(x => x.StartCode == flowmeter.Code || x.EndCode == flowmeter.Code).ToList();
                        if (linkFlowmeterList != null && linkFlowmeterList.Count > 0)
                        {
                            foreach (var linkFlowmeter in linkFlowmeterList)
                            {
                                var calcuLinkFlowmeterResult = allCalcuResultVisualDict?.GetValue(linkFlowmeter.Code) as HydroCalcuLinkResult;
                                if (calcuLinkFlowmeterResult != null)
                                {
                                    if (calcuLinkFlowmeterResult.CalcuFlow.HasValue)
                                    {
                                        calcuFlowmeterNewResult.CalcuQ = Math.Abs(calcuLinkFlowmeterResult.CalcuFlow.Value);
                                        break;
                                    }
                                }
                            }
                        }

                        hydroCalcuResult.NodeList.Remove(calcuFlowmeterResult);
                        hydroCalcuResult.NodeList.Add(calcuFlowmeterNewResult);
                        if (calcuFlowmeterNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allFlowmeterMinorLossEvaluationList != null && allFlowmeterMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var flowmeterMinorLossEvaluation in allFlowmeterMinorLossEvaluationList)
                                {
                                    if (flowmeterMinorLossEvaluation.IsMeet(calcuFlowmeterNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = flowmeter.Code,
                                            Message = $"[{flowmeter.Name}]{flowmeterMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }


            #endregion

            #region 压力表

            var allPressmeterList = hydroInfo.Pressmeters;
            if (allPressmeterList != null && allPressmeterList.Count > 0)
            {
                var allPressmeterMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Pressmeter).ToList();
                foreach (var pressmeter in allPressmeterList)
                {
                    var calcuPressmeterResult = allCalcuResultVisualDict?.GetValue(pressmeter.Code) as HydroCalcuNodeResult;
                    if (calcuPressmeterResult != null)
                    {
                        var calcuPressmeterNewResult = new HydroCalcuPressmeterResult(calcuPressmeterResult);
                        calcuPressmeterNewResult.CalcuPr = isHead ? calcuPressmeterResult.CalcuHead : calcuPressmeterResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuPressmeterResult);
                        hydroCalcuResult.NodeList.Add(calcuPressmeterNewResult);
                        if (calcuPressmeterNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allPressmeterMinorLossEvaluationList != null && allPressmeterMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var pressmeterMinorLossEvaluation in allPressmeterMinorLossEvaluationList)
                                {
                                    if (pressmeterMinorLossEvaluation.IsMeet(calcuPressmeterNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = pressmeter.Code,
                                            Message = $"[{pressmeter.Name}]{pressmeterMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 管道

            var allPipeList = hydroInfo.Pipes;
            if (allPipeList != null && allPipeList.Count > 0)
            {
                var allPipeFrictionLossKmEvaluationList = allFrictionLossKmEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Pipe).ToList();
                allPipeFrictionLossKmEvaluationList = null;//测试代码
                foreach (var pipe in allPipeList)
                {
                    var calcuPipeResult = allCalcuResultVisualDict?.GetValue(pipe.Code) as HydroCalcuLinkResult;
                    if (calcuPipeResult != null)
                    {
                        var calcuPipeNewResult = new HydroCalcuPipeResult(calcuPipeResult);
                        if (calcuPipeResult.CalcuFlow.HasValue)
                        {
                            calcuPipeNewResult.CalcuQ = Math.Abs(calcuPipeResult.CalcuFlow.Value);
                            var startPipeCode = calcuPipeResult.CalcuFlow.Value > 0 ? pipe.StartCode : pipe.EndCode;
                            var calcuStartPipeNodeResult = allCalcuResultVisualDict?.GetValue(startPipeCode) as HydroCalcuNodeResult;
                            if (calcuStartPipeNodeResult != null)
                            {
                                calcuPipeNewResult.CalcuPr1 = isHead ? calcuStartPipeNodeResult.CalcuHead : calcuStartPipeNodeResult.CalcuPress;
                            }
                            var endPipeCode = calcuPipeResult.CalcuFlow.Value > 0 ? pipe.EndCode : pipe.StartCode;
                            var calcuEndPipeNodeResult = allCalcuResultVisualDict?.GetValue(endPipeCode) as HydroCalcuNodeResult;
                            if (calcuEndPipeNodeResult != null)
                            {
                                calcuPipeNewResult.CalcuPr2 = isHead ? calcuEndPipeNodeResult.CalcuHead : calcuEndPipeNodeResult.CalcuPress;
                            }
                        }

                        hydroCalcuResult.LinkList.Remove(calcuPipeResult);
                        hydroCalcuResult.LinkList.Add(calcuPipeNewResult);
                        if (calcuPipeNewResult.CalcuFrictionLoss.HasValue)
                        {
                            if (pipe.Length > 0)
                            {
                                if (allPipeFrictionLossKmEvaluationList != null && allPipeFrictionLossKmEvaluationList.Count > 0)
                                {
                                    var pipeFrictionLossKm = calcuPipeNewResult.CalcuFrictionLoss.Value / pipe.Length * 1000;
                                    foreach (var pipeFrictionLossKmEvaluation in allPipeFrictionLossKmEvaluationList)
                                    {
                                        if (pipeFrictionLossKmEvaluation.IsMeet(pipeFrictionLossKm))
                                        {
                                            hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                            {
                                                Code = pipe.Code,
                                                Message = $"[{pipe.Name}]{pipeFrictionLossKmEvaluation.EvaluateContent}"
                                            });
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }


            #endregion

            #region 过渡件

            var allTranslationList = hydroInfo.Translations;
            if (allTranslationList != null && allTranslationList.Count > 0)
            {
                var allTranslationMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Translation).ToList();
                foreach (var translation in allTranslationList)
                {
                    var calcuTranslationResult = allCalcuResultVisualDict?.GetValue(translation.Code) as HydroCalcuLinkResult;
                    if (calcuTranslationResult != null)
                    {
                        var calcuTranslationNewResult = new HydroCalcuTranslationResult(calcuTranslationResult);
                        if (calcuTranslationResult.CalcuFlow.HasValue)
                        {
                            calcuTranslationNewResult.CalcuQ = Math.Abs(calcuTranslationResult.CalcuFlow.Value);
                            var startTranslationCode = calcuTranslationResult.CalcuFlow.Value > 0 ? translation.StartCode : translation.EndCode;
                            var calcuStartTranslationNodeResult = allCalcuResultVisualDict?.GetValue(startTranslationCode) as HydroCalcuNodeResult;
                            if (calcuStartTranslationNodeResult != null)
                            {
                                calcuTranslationNewResult.CalcuPr1 = isHead ? calcuStartTranslationNodeResult.CalcuHead : calcuStartTranslationNodeResult.CalcuPress;
                            }
                            var endTranslationCode = calcuTranslationResult.CalcuFlow.Value > 0 ? translation.EndCode : translation.StartCode;
                            var calcuEndTranslationNodeResult = allCalcuResultVisualDict?.GetValue(endTranslationCode) as HydroCalcuNodeResult;
                            if (calcuEndTranslationNodeResult != null)
                            {
                                calcuTranslationNewResult.CalcuPr2 = isHead ? calcuEndTranslationNodeResult.CalcuHead : calcuEndTranslationNodeResult.CalcuPress;
                            }
                        }

                        hydroCalcuResult.LinkList.Remove(calcuTranslationResult);
                        hydroCalcuResult.LinkList.Add(calcuTranslationNewResult);
                        if (calcuTranslationNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allTranslationMinorLossEvaluationList != null && allTranslationMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var translationMinorLossEvaluation in allTranslationMinorLossEvaluationList)
                                {
                                    if (translationMinorLossEvaluation.IsMeet(calcuTranslationNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = translation.Code,
                                            Message = $"[{translation.Name}]{translationMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 水泵

            var allPumpList = hydroInfo.Pumps;
            if (allPumpList != null && allPumpList.Count > 0)
            {
                var allPumpFlowRunEvaluationList = allFlowRunEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Pump).ToList();
                foreach (var pump in allPumpList)
                {
                    var calcuPumpResult = allCalcuResultVisualDict?.GetValue(pump.Code) as HydroCalcuLinkResult;
                    if (calcuPumpResult != null)
                    {
                        var calcuPumpNewResult = new HydroCalcuPumpResult(calcuPumpResult);
                        if (calcuPumpResult.CalcuFlow.HasValue)
                        {
                            //流量
                            calcuPumpNewResult.CalcuQ = Math.Abs(calcuPumpResult.CalcuFlow.Value);

                            //进口压力
                            var startPumpCode = calcuPumpResult.CalcuFlow.Value > 0 ? pump.StartCode : pump.EndCode;
                            var startPumpNode = allNodeList?.Find(x => x.Code == startPumpCode);
                            if (startPumpNode != null)
                            {
                                var calcuStartPumpNodeResult = allCalcuResultVisualDict?.GetValue(startPumpCode) as HydroCalcuNodeResult;
                                if (calcuStartPumpNodeResult != null)
                                {
                                    calcuPumpNewResult.CalcuPr1 = isHead ? calcuStartPumpNodeResult.CalcuHead : calcuStartPumpNodeResult.CalcuPress;
                                }
                            }

                            //出口压力
                            var endPumpCode = calcuPumpResult.CalcuFlow.Value > 0 ? pump.EndCode : pump.StartCode;
                            var endPumpNode = allNodeList?.Find(x => x.Code == endPumpCode);
                            if (endPumpNode != null)
                            {
                                var calcuEndPumpNodeResult = allCalcuResultVisualDict?.GetValue(endPumpCode) as HydroCalcuNodeResult;
                                if (calcuEndPumpNodeResult != null)
                                {
                                    calcuPumpNewResult.CalcuPr2 = isHead ? calcuEndPumpNodeResult.CalcuHead : calcuEndPumpNodeResult.CalcuPress;
                                }
                            }

                            if (calcuPumpNewResult.CalcuQ > 0)
                            {
                                //扬程
                                if (calcuPumpNewResult.CalcuPr1.HasValue && calcuPumpNewResult.CalcuPr2.HasValue)
                                {
                                    var pr1 = CalculationHelper.M2Mpa(calcuPumpNewResult.CalcuPr1.Value);
                                    var pr2 = CalculationHelper.M2Mpa(calcuPumpNewResult.CalcuPr2.Value);
                                    double? d1 = pump.InletDiameter < 1 ? null : pump.InletDiameter;
                                    double? d2 = pump.OutletDiameter < 1 ? null : pump.OutletDiameter;
                                    double? z1 = (startPumpNode as HydroJunctionInfo)?.Elev;
                                    double? z2 = (endPumpNode as HydroJunctionInfo)?.Elev;
                                    calcuPumpNewResult.CalcuH = Yw.Pump.CalculationHelper.CalcuH(pr1, pr2, calcuPumpNewResult.CalcuQ.Value, d1, d2, z1, z2);
                                }

                                //功率
                                if (pump.LinkStatus == Yw.Hydro.PumpStatus.Open)
                                {
                                    var curveqp = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQP);
                                    if (curveqp != null)
                                    {
                                        if (curveqp.CurveData != null && curveqp.CurveData.Count > 3)
                                        {
                                            var point2dList = curveqp.CurveData.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
                                            var point2dSimularList = point2dList.GetQPPointListByN(pump.RatedN, pump.RatedN * pump.SpeedRatio);
                                            var pumpCurveQp = new Yw.Pump.CurveQP(Yw.Ahart.eFeatType.Cubic, point2dSimularList);
                                            calcuPumpNewResult.CalcuP = pumpCurveQp.FeatCurve.GetPointYUnlimited(calcuPumpNewResult.CalcuQ.Value);
                                        }
                                    }
                                }

                                //效率
                                if (calcuPumpNewResult.CalcuH.HasValue && calcuPumpNewResult.CalcuP.HasValue)
                                {
                                    calcuPumpNewResult.CalcuE = Yw.Pump.CalculationHelper.CalcuE(calcuPumpNewResult.CalcuQ.Value, calcuPumpNewResult.CalcuH.Value, calcuPumpNewResult.CalcuP.Value);
                                    if (calcuPumpNewResult.CalcuE.Value > 95)
                                    {
                                        calcuPumpNewResult.CalcuE = 95;
                                    }
                                }

                            }

                        }
                        hydroCalcuResult.LinkList.Remove(calcuPumpResult);
                        hydroCalcuResult.LinkList.Add(calcuPumpNewResult);

                        if (pump.LinkStatus == Yw.Hydro.PumpStatus.Open)
                        {
                            if (calcuPumpNewResult.CalcuFlow.HasValue)
                            {
                                if (allPumpFlowRunEvaluationList != null && allPumpFlowRunEvaluationList.Count > 0)
                                {
                                    foreach (var pumpFlowRunEvaluation in allPumpFlowRunEvaluationList)
                                    {
                                        if (pumpFlowRunEvaluation.IsMeet(calcuPumpNewResult.CalcuFlow.Value))
                                        {
                                            hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                            {
                                                Code = pump.Code,
                                                Message = $"[{pump.Name}]{pumpFlowRunEvaluation.EvaluateContent}"
                                            });
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 阀门

            var allValveList = hydroInfo.Valves;
            if (allValveList != null && allValveList.Count > 0)
            {
                var allValveMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Valve).ToList();
                foreach (var valve in allValveList)
                {
                    var calcuValveResult = allCalcuResultVisualDict?.GetValue(valve.Code) as HydroCalcuLinkResult;
                    if (calcuValveResult != null)
                    {
                        var calcuValveNewResult = new HydroCalcuValveResult(calcuValveResult);
                        if (calcuValveResult.CalcuFlow.HasValue)
                        {
                            calcuValveNewResult.CalcuQ = Math.Abs(calcuValveResult.CalcuFlow.Value);
                            var startValveCode = calcuValveResult.CalcuFlow.Value > 0 ? valve.StartCode : valve.EndCode;
                            var calcuStartValveNodeResult = allCalcuResultVisualDict?.GetValue(startValveCode) as HydroCalcuNodeResult;
                            if (calcuStartValveNodeResult != null)
                            {
                                calcuValveNewResult.CalcuPr1 = isHead ? calcuStartValveNodeResult.CalcuHead : calcuStartValveNodeResult.CalcuPress;
                            }
                            var endValveCode = calcuValveResult.CalcuFlow.Value > 0 ? valve.EndCode : valve.StartCode;
                            var calcuEndValveNodeResult = allCalcuResultVisualDict?.GetValue(endValveCode) as HydroCalcuNodeResult;
                            if (calcuEndValveNodeResult != null)
                            {
                                calcuValveNewResult.CalcuPr2 = isHead ? calcuEndValveNodeResult.CalcuHead : calcuEndValveNodeResult.CalcuPress;
                            }
                        }

                        hydroCalcuResult.LinkList.Remove(calcuValveResult);
                        hydroCalcuResult.LinkList.Add(calcuValveNewResult);
                        if (calcuValveNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allValveMinorLossEvaluationList != null && allValveMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var valveMinorLossEvaluation in allValveMinorLossEvaluationList)
                                {
                                    if (valveMinorLossEvaluation.IsMeet(calcuValveNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = valve.Code,
                                            Message = $"[{valve.Name}]{valveMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 换热器

            var allExchangerList = hydroInfo.Exchangers;
            if (allExchangerList != null && allExchangerList.Count > 0)
            {
                var allExchangerMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Exchanger).ToList();
                foreach (var exchanger in allExchangerList)
                {
                    var calcuExchangerResult = allCalcuResultVisualDict?.GetValue(exchanger.Code) as HydroCalcuLinkResult;
                    if (calcuExchangerResult != null)
                    {
                        var calcuExchangerNewResult = new HydroCalcuExchangerResult(calcuExchangerResult);
                        if (calcuExchangerResult.CalcuFlow.HasValue)
                        {
                            calcuExchangerNewResult.CalcuQ = Math.Abs(calcuExchangerResult.CalcuFlow.Value);
                            var startExchangerCode = calcuExchangerResult.CalcuFlow.Value > 0 ? exchanger.StartCode : exchanger.EndCode;
                            var calcuStartExchangerNodeResult = allCalcuResultVisualDict?.GetValue(startExchangerCode) as HydroCalcuNodeResult;
                            if (calcuStartExchangerNodeResult != null)
                            {
                                calcuExchangerNewResult.CalcuPr1 = isHead ? calcuStartExchangerNodeResult.CalcuHead : calcuStartExchangerNodeResult.CalcuPress;
                            }
                            var endExchangerCode = calcuExchangerResult.CalcuFlow.Value > 0 ? exchanger.EndCode : exchanger.StartCode;
                            var calcuEndExchangerNodeResult = allCalcuResultVisualDict?.GetValue(endExchangerCode) as HydroCalcuNodeResult;
                            if (calcuEndExchangerNodeResult != null)
                            {
                                calcuExchangerNewResult.CalcuPr2 = isHead ? calcuEndExchangerNodeResult.CalcuHead : calcuEndExchangerNodeResult.CalcuPress;
                            }
                        }

                        hydroCalcuResult.LinkList.Remove(calcuExchangerResult);
                        hydroCalcuResult.LinkList.Add(calcuExchangerNewResult);

                        if (calcuExchangerNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allExchangerMinorLossEvaluationList != null && allExchangerMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var exchangerMinorLossEvaluation in allExchangerMinorLossEvaluationList)
                                {
                                    if (exchangerMinorLossEvaluation.IsMeet(calcuExchangerNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = exchanger.Code,
                                            Message = $"[{exchanger.Name}]{exchangerMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            #region 压缩机

            var allCompressorList = hydroInfo.Compressors;
            if (allCompressorList != null && allCompressorList.Count > 0)
            {
                var allCompressorMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Compressor).ToList();
                foreach (var compressor in allCompressorList)
                {
                    var calcuCompressorResult = allCalcuResultVisualDict?.GetValue(compressor.Code) as HydroCalcuLinkResult;
                    if (calcuCompressorResult != null)
                    {
                        var calcuCompressorNewResult = new HydroCalcuCompressorResult(calcuCompressorResult);
                        if (calcuCompressorResult.CalcuFlow.HasValue)
                        {
                            calcuCompressorNewResult.CalcuQ = Math.Abs(calcuCompressorResult.CalcuFlow.Value);
                            var startCompressorCode = calcuCompressorResult.CalcuFlow.Value > 0 ? compressor.StartCode : compressor.EndCode;
                            var calcuStartCompressorNodeResult = allCalcuResultVisualDict?.GetValue(startCompressorCode) as HydroCalcuNodeResult;
                            if (calcuStartCompressorNodeResult != null)
                            {
                                calcuCompressorNewResult.CalcuPr1 = isHead ? calcuStartCompressorNodeResult.CalcuHead : calcuStartCompressorNodeResult.CalcuPress;
                            }
                            var endCompressorCode = calcuCompressorResult.CalcuFlow.Value > 0 ? compressor.EndCode : compressor.StartCode;
                            var calcuEndCompressorNodeResult = allCalcuResultVisualDict?.GetValue(endCompressorCode) as HydroCalcuNodeResult;
                            if (calcuEndCompressorNodeResult != null)
                            {
                                calcuCompressorNewResult.CalcuPr2 = isHead ? calcuEndCompressorNodeResult.CalcuHead : calcuEndCompressorNodeResult.CalcuPress;
                            }
                        }

                        hydroCalcuResult.LinkList.Remove(calcuCompressorResult);
                        hydroCalcuResult.LinkList.Add(calcuCompressorNewResult);

                        if (calcuCompressorNewResult.CalcuMinorLoss.HasValue)
                        {
                            if (allCompressorMinorLossEvaluationList != null && allCompressorMinorLossEvaluationList.Count > 0)
                            {
                                foreach (var compressorMinorLossEvaluation in allCompressorMinorLossEvaluationList)
                                {
                                    if (compressorMinorLossEvaluation.IsMeet(calcuCompressorNewResult.CalcuMinorLoss.Value))
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = compressor.Code,
                                            Message = $"[{compressor.Name}]{compressorMinorLossEvaluation.EvaluateContent}"
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            return hydroCalcuResult;
        }




    }
}