using Yw.EPAnet;
using Yw.Hydro;
using Yw.Model;

namespace Yw.WinFrmUI
{
    /// <summary>
    /// 
    /// </summary>
    public static class HydroModelInfoExtensions
    {
        /// <summary>
        /// 获取可见字典
        /// </summary>
        public static Dictionary<string, HydroVisualInfo> GetVisualDict(this Yw.Model.HydroModelInfo hydroInfo)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            var allVisualList = hydroInfo.GetAllVisuals();
            return allVisualList?.ToDictionary(x => x.Code);
        }

        /// <summary>
        /// 计算
        /// </summary>
        public static HydroCalcuResult Calcu(this Yw.Model.HydroModelInfo hydroInfo, string calcuMode = Yw.EPAnet.CalcuMode.Simple)
        {
            var network = hydroInfo.ToNetwork();
            if (network == null)
            {
                return default;
            }
            var calcuResult = network.Calcu(calcuMode);
            if (calcuResult == null)
            {
                return default;
            }
            return hydroInfo.GetCalcuResult(calcuResult);
        }

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

            var hydroCalcuResult = new HydroCalcuResult(calcuResult);

            //流量计
            var allFlowmeterList = hydroInfo.Flowmeters;
            if (allFlowmeterList != null && allFlowmeterList.Count > 0)
            {
                var allLinkList = hydroInfo.GetAllLinks();
                foreach (var flowmeter in allFlowmeterList)
                {
                    var calcuFlowmeterResult = hydroCalcuResult.NodeList?.Find(x => x.Code == flowmeter.Code);
                    if (calcuFlowmeterResult != null)
                    {
                        var calcuFlowmeterNewResult = new HydroCalcuFlowmeterResult(calcuFlowmeterResult);
                        var calcuFlowmeterLinkResultList = new List<HydroCalcuLinkResult>();
                        var flowmeterLinkList = allLinkList?.Where(x => x.StartCode == flowmeter.Code || x.EndCode == flowmeter.Code).ToList();
                        if (flowmeterLinkList != null && flowmeterLinkList.Count > 0)
                        {
                            foreach (var flowmeterLink in flowmeterLinkList)
                            {
                                var calcuFlowmeterLinkResult = hydroCalcuResult.LinkList?.Find(x => x.Code == flowmeterLink.Code);
                                if (calcuFlowmeterLinkResult != null)
                                {
                                    calcuFlowmeterLinkResultList.Add(calcuFlowmeterLinkResult);
                                }
                            }
                        }
                        if (calcuFlowmeterLinkResultList.Exists(x => x.CalcuFlow.HasValue))
                        {
                            calcuFlowmeterNewResult.CalcuQ = calcuFlowmeterLinkResultList.Where(x => x.CalcuFlow.HasValue).Average(x => x.CalcuFlow.Value);
                        }
                        hydroCalcuResult.NodeList.Remove(calcuFlowmeterResult);
                        hydroCalcuResult.NodeList.Add(calcuFlowmeterNewResult);
                    }
                }
            }

            //压力表
            var allPressmeterList = hydroInfo.Pressmeters;
            if (allPressmeterList != null && allPressmeterList.Count > 0)
            {
                foreach (var pressmeter in allPressmeterList)
                {
                    var calcuPressmeterResult = hydroCalcuResult.NodeList?.Find(x => x.Code == pressmeter.Code);
                    if (calcuPressmeterResult != null)
                    {
                        var calcuPressmeterNewResult = new HydroCalcuPressmeterResult(calcuPressmeterResult);
                        calcuPressmeterNewResult.CalcuPr = calcuPressmeterResult.CalcuPress;
                        hydroCalcuResult.NodeList.Remove(calcuPressmeterResult);
                        hydroCalcuResult.NodeList.Add(calcuPressmeterNewResult);
                    }
                }
            }

            //水泵
            var allPumpList = hydroInfo.Pumps;
            if (allPumpList != null && allPumpList.Count > 0)
            {
                foreach (var pump in allPumpList)
                {
                    var calcuPumpResult = hydroCalcuResult.LinkList.Find(x => x.Code == pump.Code);
                    if (calcuPumpResult != null)
                    {
                        var calcuPumpNewResult = new HydroCalcuPumpResult(calcuPumpResult);
                        calcuPumpNewResult.CalcuQ = calcuPumpResult.CalcuFlow;
                        if (calcuPumpNewResult.CalcuQ.HasValue)
                        {
                            var calcuNodeStartResult = hydroCalcuResult.NodeList?.Find(x => x.Code == pump.StartCode);
                            var calcuNodeEndResult = hydroCalcuResult.NodeList?.Find(x => x.Code == pump.EndCode);
                            if (calcuNodeStartResult != null && calcuNodeEndResult != null)
                            {
                                if (calcuNodeStartResult.CalcuPress.HasValue && calcuNodeEndResult.CalcuPress.HasValue)
                                {
                                    calcuPumpNewResult.CalcuH = Math.Abs(calcuNodeStartResult.CalcuPress.Value - calcuNodeEndResult.CalcuPress.Value);
                                }
                                if (pump.LinkStatus == Yw.Hydro.PumpStatus.Open && pump.RatedN.HasValue)
                                {
                                    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.Value, pump.RatedN.Value * pump.SpeedRatio);
                                            var pumpCurveQp = new Yw.Pump.CurveQP(eFeatType.Cubic, point2dSimularList);
                                            calcuPumpNewResult.CalcuP = pumpCurveQp.FeatCurve.GetPointY(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);
                                }
                            }
                        }
                        hydroCalcuResult.LinkList.Remove(calcuPumpResult);
                        hydroCalcuResult.LinkList.Add(calcuPumpNewResult);

                        switch (pump.LinkStatus)
                        {
                            case Yw.Hydro.PumpStatus.Open:
                                {
                                    if (calcuPumpNewResult.CalcuFlow.HasValue)
                                    {
                                        if (calcuPumpNewResult.CalcuFlow.Value <= 0)
                                        {
                                            hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                            {
                                                Code = pump.Code,
                                                Message = $"[{pump.Name}]不满足当前工况 "
                                            });
                                        }
                                    }
                                    else
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = pump.Code,
                                            Message = $"[{pump.Name}]流量计算失败 "
                                        });
                                    }
                                }
                                break;
                            case Yw.Hydro.PumpStatus.Closed:
                                {
                                    if (calcuPumpNewResult.CalcuFlow.HasValue)
                                    {
                                        if (calcuPumpNewResult.CalcuFlow.Value > 0)
                                        {
                                            hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                            {
                                                Code = pump.Code,
                                                Message = $"[{pump.Name}]不满足当前工况 "
                                            });
                                        }
                                    }
                                    else
                                    {
                                        hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
                                        {
                                            Code = pump.Code,
                                            Message = $"[{pump.Name}]流量计算失败 "
                                        });
                                    }
                                }
                                break;
                            default: break;
                        }

                    }
                }
            }



            return hydroCalcuResult;
        }


    }
}