using Yw.Model;

namespace Yw.WinFrmUI
{
    /// <summary>
    /// 颜色分级辅助类
    /// </summary>
    public class HydroGradingHelper
    {

        /// <summary>
        /// 获取分级列表
        /// </summary>
        public static async Task<List<HydroGradingVmo>> GetGradingList(Yw.Model.HydroModelInfo hydroInfo)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            var allGradingList = await BLLFactory<Yw.BLL.HydroGrading>.Instance.GetByModelID(hydroInfo.ID);
            if (allGradingList == null || allGradingList.Count < 1)
            {
                var config = Yw.Settings.HydroParasHelper.Hydro.Grading;
                if (config != null && config.Items != null && config.Items.Count > 0)
                {
                    if (allGradingList == null)
                    {
                        allGradingList = new List<HydroGradingVmo>();
                    }
                    config.Items.ForEach(x =>
                    {
                        var vmo = new HydroGradingVmo()
                        {
                            ModelID = hydroInfo.ID,
                            Catalog = x.Catalog,
                            PropName = x.PropName,
                            SetValue = x.SetValue,
                            MinValue = x.MinValue,
                            MaxValue = x.MaxValue,
                            Color = x.Color,
                            SortCode = config.Items.IndexOf(x)
                        };
                        allGradingList.Add(vmo);
                    });
                }
            }
            return allGradingList;
        }

        /// <summary>
        /// 获取应用列表
        /// </summary>
        public static List<HydroGradingApplyViewModel> GetApplyList(Yw.Model.HydroModelInfo hydroInfo)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            var allApplyList = new List<HydroGradingApplyViewModel>();
            //闷头
            if (hydroInfo.Bluntheads != null && hydroInfo.Bluntheads.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Blunthead,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Blunthead),
                    PropName = HydroVisualCalcuProp.CalcuPress
                });
            }
            //弯头
            if (hydroInfo.Elbows != null && hydroInfo.Elbows.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Elbow,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Elbow),
                    PropName = HydroVisualCalcuProp.CalcuPress
                });
            }
            //三通
            if (hydroInfo.Threelinks != null && hydroInfo.Threelinks.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Threelink,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Threelink),
                    PropName = HydroVisualCalcuProp.CalcuPress
                });
            }
            //四通
            if (hydroInfo.Fourlinks != null && hydroInfo.Fourlinks.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Fourlink,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Fourlink),
                    PropName = HydroVisualCalcuProp.CalcuPress
                });
            }
            //喷头
            if (hydroInfo.Nozzles != null && hydroInfo.Nozzles.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Nozzle,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Nozzle),
                    PropName = HydroVisualCalcuProp.CalcuPress
                });
            }
            //消火栓
            if (hydroInfo.Hydrants != null && hydroInfo.Hydrants.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Hydrant,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Hydrant),
                    PropName = HydroVisualCalcuProp.CalcuPress
                });
            }
            //水表
            if (hydroInfo.Meters != null && hydroInfo.Meters.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Meter,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Meter),
                    PropName = HydroVisualCalcuProp.CalcuDemand
                });
            }
            //流量计
            if (hydroInfo.Flowmeters != null && hydroInfo.Flowmeters.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Flowmeter,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Flowmeter),
                    PropName = HydroVisualCalcuProp.CalcuQ
                });
            }
            //压力表
            if (hydroInfo.Pressmeters != null && hydroInfo.Pressmeters.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Pressmeter,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Pressmeter),
                    PropName = HydroVisualCalcuProp.CalcuPr
                });
            }
            //管道
            if (hydroInfo.Pipes != null && hydroInfo.Pipes.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Pipe,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Pipe),
                    PropName = HydroVisualCalcuProp.CalcuFlow
                });
            }
            //过渡件
            if (hydroInfo.Translations != null && hydroInfo.Translations.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Translation,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Translation),
                    PropName = HydroVisualCalcuProp.CalcuFlow
                });
            }
            //水泵
            if (hydroInfo.Pumps != null && hydroInfo.Pumps.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Pump,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Pump),
                    PropName = Yw.Hydro.ParterProp.LinkStatus
                });
            }
            //阀门
            if (hydroInfo.Valves != null && hydroInfo.Valves.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Valve,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Valve),
                    PropName = Yw.Hydro.ParterProp.LinkStatus
                });
            }
            //换热器
            if (hydroInfo.Exchangers != null && hydroInfo.Exchangers.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Exchanger,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Exchanger),
                    PropName = Yw.Hydro.ParterProp.LinkStatus
                });
            }
            //压缩机
            if (hydroInfo.Compressors != null && hydroInfo.Compressors.Count > 0)
            {
                allApplyList.Add(new HydroGradingApplyViewModel()
                {
                    Catalog = Yw.Hydro.ParterCatalog.Compressor,
                    CatalogName = HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Compressor),
                    PropName = Yw.Hydro.ParterProp.LinkStatus
                });
            }
            return allApplyList;
        }

        /// <summary>
        /// 获取结果列表
        /// </summary>
        public static List<HydroGradingResultViewModel> GetResultList
            (
                Yw.Model.HydroModelInfo hydroInfo,
                List<HydroGradingVmo> allGradingList,
                List<HydroGradingApplyViewModel> allApplyList,
                Dictionary<string, HydroCalcuVisualResult> allCalcuResultVisualDict
            )
        {
            if (hydroInfo == null)
            {
                return default;
            }
            var allVisualList = hydroInfo.GetAllVisuals();
            if (allVisualList == null || allVisualList.Count < 1)
            {
                return default;
            }
            var list = new List<HydroGradingResultViewModel>();
            allVisualList.ForEach(x =>
            {
                var result = GetResult(x, allGradingList, allApplyList, allCalcuResultVisualDict);
                if (result != null)
                {
                    list.Add(result);
                }
            });
            return list;
        }

        /// <summary>
        /// 获取结果
        /// </summary>
        public static HydroGradingResultViewModel GetResult
            (
                Yw.Model.HydroVisualInfo visual,
                List<HydroGradingVmo> allGradingList,
                List<HydroGradingApplyViewModel> allApplyList,
                Dictionary<string, HydroCalcuVisualResult> allCalcuResultVisualDict
            )
        {
            if (visual == null)
            {
                return default;
            }

            if (allGradingList == null || allGradingList.Count < 1)
            {
                return default;
            }
            var allCatalogGradingList = allGradingList.Where(x => x.Catalog == visual.Catalog).ToList();
            if (allCatalogGradingList == null || allCatalogGradingList.Count < 1)
            {
                return default;
            }

            if (allApplyList == null || allApplyList.Count < 1)
            {
                return default;
            }
            var apply = allApplyList.Find(x => x.Catalog == visual.Catalog);
            if (apply == null)
            {
                return default;
            }

            HydroGradingResultViewModel result = null;
            switch (apply.Catalog)
            {
                case Yw.Hydro.ParterCatalog.Pump:
                    {
                        var pump = visual as HydroPumpInfo;
                        if (pump != null)
                        {
                            switch (apply.PropName)
                            {
                                case Yw.Hydro.ParterProp.LinkStatus:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var grading = gradingList.Meet(pump.LinkStatus);
                                            if (grading != null)
                                            {
                                                result = new HydroGradingResultViewModel()
                                                {
                                                    Code = pump.Code,
                                                    Catalog = apply.Catalog,
                                                    PropName = apply.PropName,
                                                    Color = grading.Color
                                                };
                                            }
                                        }
                                    }
                                    break;
                                case HydroVisualCalcuProp.CalcuFlow:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var calcuResult = allCalcuResultVisualDict?.GetValue(pump.Code);
                                            if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                            {
                                                if (calcuLinkResult.CalcuFlow.HasValue)
                                                {
                                                    var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                    if (grading != null)
                                                    {
                                                        result = new HydroGradingResultViewModel()
                                                        {
                                                            Code = pump.Code,
                                                            Catalog = apply.Catalog,
                                                            PropName = apply.PropName,
                                                            Color = grading.Color
                                                        };
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                                case HydroVisualCalcuProp.CalcuVelocity:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var calcuResult = allCalcuResultVisualDict?.GetValue(pump.Code);
                                            if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                            {
                                                if (calcuLinkResult.CalcuVelocity.HasValue)
                                                {
                                                    var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                    if (grading != null)
                                                    {
                                                        result = new HydroGradingResultViewModel()
                                                        {
                                                            Code = pump.Code,
                                                            Catalog = apply.Catalog,
                                                            PropName = apply.PropName,
                                                            Color = grading.Color
                                                        };
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                                case HydroVisualCalcuProp.CalcuHeadLoss:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var calcuResult = allCalcuResultVisualDict?.GetValue(pump.Code);
                                            if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                            {
                                                if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                {
                                                    var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                    if (grading != null)
                                                    {
                                                        result = new HydroGradingResultViewModel()
                                                        {
                                                            Code = pump.Code,
                                                            Catalog = apply.Catalog,
                                                            PropName = apply.PropName,
                                                            Color = grading.Color
                                                        };
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                                default: break;
                            }
                        }
                    }
                    break;
                case Yw.Hydro.ParterCatalog.Valve:
                    {
                        var valve = visual as HydroValveInfo;
                        if (valve != null)
                        {
                            switch (apply.PropName)
                            {
                                case Yw.Hydro.ParterProp.LinkStatus:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var grading = gradingList.Meet(valve.LinkStatus);
                                            if (grading != null)
                                            {
                                                result = new HydroGradingResultViewModel()
                                                {
                                                    Code = valve.Code,
                                                    Catalog = apply.Catalog,
                                                    PropName = apply.PropName,
                                                    Color = grading.Color
                                                };
                                            }
                                        }
                                    }
                                    break;
                                case HydroVisualCalcuProp.CalcuFlow:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var calcuResult = allCalcuResultVisualDict?.GetValue(valve.Code);
                                            if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                            {
                                                if (calcuLinkResult.CalcuFlow.HasValue)
                                                {
                                                    var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                    if (grading != null)
                                                    {
                                                        result = new HydroGradingResultViewModel()
                                                        {
                                                            Code = valve.Code,
                                                            Catalog = apply.Catalog,
                                                            PropName = apply.PropName,
                                                            Color = grading.Color
                                                        };
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                                case HydroVisualCalcuProp.CalcuVelocity:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var calcuResult = allCalcuResultVisualDict?.GetValue(valve.Code);
                                            if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                            {
                                                if (calcuLinkResult.CalcuVelocity.HasValue)
                                                {
                                                    var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                    if (grading != null)
                                                    {
                                                        result = new HydroGradingResultViewModel()
                                                        {
                                                            Code = valve.Code,
                                                            Catalog = apply.Catalog,
                                                            PropName = apply.PropName,
                                                            Color = grading.Color
                                                        };
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                                case HydroVisualCalcuProp.CalcuHeadLoss:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var calcuResult = allCalcuResultVisualDict?.GetValue(valve.Code);
                                            if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                            {
                                                if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                {
                                                    var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                    if (grading != null)
                                                    {
                                                        result = new HydroGradingResultViewModel()
                                                        {
                                                            Code = valve.Code,
                                                            Catalog = apply.Catalog,
                                                            PropName = apply.PropName,
                                                            Color = grading.Color
                                                        };
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                                default: break;
                            }
                        }
                    }
                    break;
                case Yw.Hydro.ParterCatalog.Pipe:
                    {
                        var pipe = visual as HydroPipeInfo;
                        if (pipe != null)
                        {
                            switch (apply.PropName)
                            {
                                case HydroVisualCalcuProp.CalcuFlow:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var calcuResult = allCalcuResultVisualDict?.GetValue(pipe.Code);
                                            if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                            {
                                                if (calcuLinkResult.CalcuFlow.HasValue)
                                                {
                                                    var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                    if (grading != null)
                                                    {
                                                        result = new HydroGradingResultViewModel()
                                                        {
                                                            Code = pipe.Code,
                                                            Catalog = apply.Catalog,
                                                            PropName = apply.PropName,
                                                            Color = grading.Color
                                                        };
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                                case HydroVisualCalcuProp.CalcuVelocity:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var calcuResult = allCalcuResultVisualDict?.GetValue(pipe.Code);
                                            if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                            {
                                                if (calcuLinkResult.CalcuVelocity.HasValue)
                                                {
                                                    var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                    if (grading != null)
                                                    {
                                                        result = new HydroGradingResultViewModel()
                                                        {
                                                            Code = pipe.Code,
                                                            Catalog = apply.Catalog,
                                                            PropName = apply.PropName,
                                                            Color = grading.Color
                                                        };
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                                case HydroVisualCalcuProp.CalcuHeadLoss:
                                    {
                                        var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                        if (gradingList != null && gradingList.Count > 0)
                                        {
                                            var calcuResult = allCalcuResultVisualDict?.GetValue(pipe.Code);
                                            if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                            {
                                                if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                {
                                                    var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                    if (grading != null)
                                                    {
                                                        result = new HydroGradingResultViewModel()
                                                        {
                                                            Code = pipe.Code,
                                                            Catalog = apply.Catalog,
                                                            PropName = apply.PropName,
                                                            Color = grading.Color
                                                        };
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    break;
                                default: break;
                            }
                        }
                    }
                    break;
                default: break;
            }
            return result;
        }


    }
}