namespace HStation.WinFrmUI
{
    public class AssetsMatchingHelper
    {
        private readonly Lazy<BLL.PhartDiagramRelation> _bll_ex = new();
        private const double _caliberTolerance = 10.0;
        private const double _speedTolerance = 100;
        private const double _flowTolerance = 10;
        private const double _headTolerance = 5;
        private const double _powerTolerance = 0.05;
        private const double _valveLift = 10;//阀门开度范围
        private const int _angle = 1;//角度范围

        //资产自动匹配
        public static bool Matching(HydroMatchingViewModel assetsAutoMatchingView, out string Error)
        {
            Error = string.Empty;
            bool IsMaching = false;
            var AssetsPumpMain = new BLL.AssetsPumpMain();
            var AdaptingManage = new BLL.AdaptingManage();
            var pipeLineManage = new BLL.AssetsPipeMain();
            var AssetsValveMain = new BLL.AssetsValveMain();
            var AssetsElbowMain = new BLL.AssetsElbowMain();
            var AssetsThreelinkMain = new BLL.AssetsThreelinkMain();
            var AssetsFourlinkMain = new BLL.AssetsFourlinkMain();
            var AssetsSprinkler = new BLL.AssetsSprinklerMain();
            var AssetsExchanger = new BLL.AssetsExchangerMain();
            var AssetsCompressorMain = new BLL.AssetsCompressorMain();
            var AssetsBluntheadMain = new BLL.AssetsBluntheadMain();
            var AssetsTankMain = new BLL.AssetsTankMain();
            var AssetsMeterMain = new BLL.AssetsMeterMain();
            var AssetsFlowmeterMain = new BLL.AssetsFlowmeterMain();
            var AssetsHydrantMain = new BLL.AssetsHydrantMain();
            var AssetsPressmeterMain = new BLL.AssetsPressmeterMain();
            var AssetsTranslationMain = new BLL.AssetsTranslationMain();
            var AssetsCoolingMain = new BLL.AssetsCoolingMain();
            try
            {
                var allPump = Task.Run(async () => await AssetsPumpMain.GetAll()).Result;
                //   var allAdapting = Task.Run(async () => await adaptingManage.GetAll()).Result;
                var allPipeLine = Task.Run(async () => await pipeLineManage.GetAll()).Result;
                var allValve = Task.Run(async () => await AssetsValveMain.GetAll()).Result;
                var allElbow = Task.Run(async () => await AssetsElbowMain.GetAll()).Result;
                var allThreeLink = Task.Run(async () => await AssetsThreelinkMain.GetAll()).Result;
                var allFourLink = Task.Run(async () => await AssetsFourlinkMain.GetAll()).Result;
                var allSprinkler = Task.Run(async () => await AssetsSprinkler.GetAll()).Result;
                var allExchanger = Task.Run(async () => await AssetsExchanger.GetAll()).Result;
                var allCompressorMain = Task.Run(async () => await AssetsCompressorMain.GetAll()).Result;
                var allBluntheadMain = Task.Run(async () => await AssetsBluntheadMain.GetAll()).Result;
                var allTankMain = Task.Run(async () => await AssetsTankMain.GetAll()).Result;
                var allMeterMain = Task.Run(async () => await AssetsMeterMain.GetAll()).Result;
                var allFlowmeterMain = Task.Run(async () => await AssetsFlowmeterMain.GetAll()).Result;
                var allHydrantMain = Task.Run(async () => await AssetsHydrantMain.GetAll()).Result;
                var allPressmeterMain = Task.Run(async () => await AssetsPressmeterMain.GetAll()).Result;
                var allTranslationMain = Task.Run(async () => await AssetsTranslationMain.GetAll()).Result;
                var allCoolingMain = Task.Run(async () => await AssetsCoolingMain.GetAll()).Result;
                //泵匹配
                foreach (var item in assetsAutoMatchingView.Pumps)
                {
                    if (MatchingPumps(item, allPump))
                    {
                        IsMaching = true;
                    }
                }
                //三通匹配
                foreach (var item in assetsAutoMatchingView.Threelinks)
                {
                    if (Matching(item, allThreeLink))
                    {
                        IsMaching = true;
                    }
                }
                //四通匹配
                foreach (var item in assetsAutoMatchingView.Fourlinks)
                {
                    if (Matching(item, allFourLink))
                    {
                        IsMaching = true;
                    }
                }
                //管道匹配
                foreach (var item in assetsAutoMatchingView.Pipes)
                {
                    if (Matching(item, allPipeLine))
                    {
                        IsMaching = true;
                    }
                }
                //阀门匹配
                foreach (var item in assetsAutoMatchingView.Valves)
                {
                    if (Matching(item, allValve))
                    {
                        IsMaching = true;
                    }
                }
                //弯头匹配
                foreach (var item in assetsAutoMatchingView.Elbows)
                {
                    if (Matching(item, allElbow))
                    {
                        IsMaching = true;
                    }
                }
                //喷头匹配
                foreach (var item in assetsAutoMatchingView.Nozzles)
                {
                    if (Matching(item, allSprinkler))
                    {
                        IsMaching = true;
                    }
                }

                //喷头匹配
                foreach (var item in assetsAutoMatchingView.Coolings)
                {
                    if (Matching(item, allCoolingMain))
                    {
                        IsMaching = true;
                    }
                }
                //闷头匹配
                foreach (var item in assetsAutoMatchingView.Bluntheads)
                {
                    if (Matching(item, allBluntheadMain))
                    {
                        IsMaching = true;
                    }
                }
                //换热器匹配
                foreach (var item in assetsAutoMatchingView.Exchangers)
                {
                    if (Matching(item, allExchanger))
                    {
                        IsMaching = true;
                    }
                }
                //压缩机匹配
                foreach (var item in assetsAutoMatchingView.Compressors)
                {
                    if (Matching(item, allCompressorMain))
                    {
                        IsMaching = true;
                    }
                }
                //水池匹配
                foreach (var item in assetsAutoMatchingView.Tanks)
                {
                    if (Matching(item, allTankMain))
                    {
                        IsMaching = true;
                    }
                }
                //水表匹配
                foreach (var item in assetsAutoMatchingView.Meters)
                {
                    if (Matching(item, allMeterMain))
                    {
                        IsMaching = true;
                    }
                }
                //流量计匹配
                foreach (var item in assetsAutoMatchingView.Flowmeters)
                {
                    if (Matching(item, allFlowmeterMain))
                    {
                        IsMaching = true;
                    }
                }
                //消火栓匹配
                foreach (var item in assetsAutoMatchingView.Hydrants)
                {
                    if (Matching(item, allHydrantMain))
                    {
                        IsMaching = true;
                    }
                }
                //压力表匹配
                foreach (var item in assetsAutoMatchingView.Pressmeters)
                {
                    if (Matching(item, allPressmeterMain))
                    {
                        IsMaching = true;
                    }
                }
                //过渡件匹配
                foreach (var item in assetsAutoMatchingView.Translations)
                {
                    if (Matching(item, allTranslationMain))
                    {
                        IsMaching = true;
                    }
                }
            }
            catch (Exception ex)
            {
                Error = ex.Message;
                return false;
            }
            return IsMaching;
        }

        //泵匹配
        public static bool MatchingPumps(HydroPumpMatchingViewModel InputModel, List<Vmo.AssetsPumpMainVmo> AssetsPumpMainVmos)
        {
            if (AssetsPumpMainVmos == null)
            {
                return true;
            }
            Vmo.AssetsPumpMainVmo vmo = null;
            int startCount = 0;
            // 尝试绝对匹配
            var absoluteMatch = AssetsPumpMainVmos.Where(item =>
            (InputModel.RatedN == null || InputModel.RatedN == item.RatedSpeed) &&
            (InputModel.RatedQ == null || InputModel.RatedQ == item.RatedFlow) &&
            (InputModel.RatedH == null || InputModel.RatedH == item.RatedHead) &&
            (InputModel.RatedP == item.RatedPower)).ToList();
            if (absoluteMatch != null && absoluteMatch.Count != 0)
            {
                foreach (var item in absoluteMatch)
                {
                    int commonCount = GetIntersect(InputModel.ModelType, item.Name);
                    if (commonCount > startCount)
                    {
                        vmo = item;
                        startCount = commonCount;
                    }
                }
            }
            else
            {
                // 尝试区间匹配
                var rangeMatch = AssetsPumpMainVmos.Where(item =>
                   (InputModel.RatedN > 0 ? Math.Abs(InputModel.RatedN - item.RatedSpeed) <= _speedTolerance : true) &&
                   (InputModel.RatedQ > 0 ? Math.Abs(InputModel.RatedQ - item.RatedFlow) <= _flowTolerance : true) &&
                   (InputModel.RatedH > 0 ? Math.Abs(InputModel.RatedH - item.RatedHead) <= _headTolerance : true) &&
                   (Math.Abs(InputModel.RatedP - item.RatedPower) <= _powerTolerance)).ToList();
                if (rangeMatch != null && rangeMatch.Count != 0)
                {
                    foreach (var item in rangeMatch)
                    {
                        int commonCount = GetIntersect(InputModel.ModelType, item.Name);
                        if (commonCount > startCount)
                        {
                            vmo = item;
                            startCount = commonCount;
                        }
                    }
                }
            }
            //
            if (vmo == null)
            {
                foreach (var item in AssetsPumpMainVmos)
                {
                    int commonCount = GetIntersect(InputModel.ModelType, item.Name);
                    if (commonCount > startCount)
                    {
                        vmo = item;
                        startCount = commonCount;
                    }
                }
            }
            if (vmo != null)
            {
                InputModel.MatchingRatedH = vmo.RatedHead;
                InputModel.MatchingRatedN = vmo.RatedSpeed;
                InputModel.MatchingRatedQ = vmo.RatedFlow;
                InputModel.MatchingRatedP = vmo.RatedPower;
                InputModel.MatchingDbId = vmo.ID.ToString();
                InputModel.MatchingModelType = vmo.Name;
                var list = Task.Run(async () => await new BLL.PhartDiagramRelation().GetExByObjectTypeAndObjectID(HStation.Assets.DataType.PumpMain, vmo.ID)).Result;
                if (list != null && list.Count > 0)
                {
                    var def = list.OrderByDescending(x => x.Importance).First();
                    InputModel.MatchingCurveDbId = def.ID.ToString();
                    var diagram = def.Diagram.GetDefaultVmo();
                    var qh = diagram.QH.GetFeatPointList();
                    var qp = diagram.QP.GetFeatPointList();
                    var qe = diagram.QE.GetFeatPointList();
                    InputModel.MatchingCurveQH = new List<HydroCurvePointViewModel>();
                    InputModel.MatchingCurveQP = new List<HydroCurvePointViewModel>();
                    InputModel.MatchingCurveQE = new List<HydroCurvePointViewModel>();
                    foreach (var item in qh)
                    {
                        InputModel.MatchingCurveQH.Add(new HydroCurvePointViewModel(item.X, item.Y));
                    }
                    foreach (var item in qp)
                    {
                        InputModel.MatchingCurveQP.Add(new HydroCurvePointViewModel(item.X, item.Y));
                    }
                    foreach (var item in qe)
                    {
                        InputModel.MatchingCurveQE.Add(new HydroCurvePointViewModel(item.X, item.Y));
                    }
                }

                return true;
            }
            return false;
        }

        //阀门匹配
        public static bool Matching(HydroValveMatchingViewModel input, List<AssetsValveMainVmo> valveMainVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (valveMainVmos == null || valveMainVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsValveMainVmo, double>();
            foreach (var item in valveMainVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in valveMainVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in valveMainVmos)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int caliberWeight = 1;
            if (input.Diameter > 0)
            {
                foreach (var item in valveMainVmos)
                {
                    if (item.Caliber.HasValue)
                    {
                        var diff = Math.Abs(item.Caliber.Value - input.Diameter);
                        dict[item] += diff / input.Diameter * 100 * caliberWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in valveMainVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in valveMainVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }
            var valve = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = valve.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = valve.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = valve.Material;
            }
            if (input.Diameter <= 0 && valve.Caliber.HasValue)
            {
                input.Diameter = valve.Caliber.Value;
            }
            if (input.MinorLoss < 0)
            {
                input.MatchingMinorLoss = valve.MinorLoss;
            }
            if (input.ValveSetting == null)
            {
                input.MatchingValveSetting = valve.ValveSetting;
            }
            if (input.CurveDbId == null)
            {
                var list = Task.Run(async () =>
                    await new BLL.PhartDiagramRelation().GetExByObjectTypeAndObjectID(HStation.Assets.DataType.ValveMain, valve.ID)).Result;
                if (list != null && list.Count > 0)
                {
                    var def = list.OrderByDescending(x => x.Importance).First();
                    input.MatchingCurveDbId = def.ID.ToString();
                    var curve = def.Diagram.GraphList[0].GetFeatPointList();
                    input.MatchingCurveQL = new List<HydroCurvePointViewModel>();
                    /*   foreach (var item in curve)
                       {
                           input.MatchingCurveQL.Add(new HydroCurvePointViewModel(item.X, item.Y));
                       }*/

                    input.MatchingCurveOL = new List<HydroCurvePointViewModel>();
                    foreach (var item in curve)
                    {
                        input.MatchingCurveOL.Add(new HydroCurvePointViewModel(item.X, item.Y));
                    }
                }
                return true;
            }
            return false;
        }

        //管道匹配
        public static bool Matching(HydroPipeMatchingViewModel input, List<AssetsPipeMainVmo> pipeLineMainVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (pipeLineMainVmos == null || pipeLineMainVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsPipeMainVmo, double>();
            foreach (var item in pipeLineMainVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in pipeLineMainVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in pipeLineMainVmos)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int caliberWeight = 1;
            if (input.Diameter > 0)
            {
                foreach (var item in pipeLineMainVmos)
                {
                    if (item.Caliber.HasValue)
                    {
                        var diff = Math.Abs(item.Caliber.Value - input.Diameter);
                        dict[item] += diff / input.Diameter * 100 * caliberWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in pipeLineMainVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in pipeLineMainVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var pipe = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = pipe.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = pipe.Name;
            }

            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = pipe.Material;
            }
            if (input.MinorLoss < 0)
            {
                input.MatchingMinorLoss = pipe.Hazen;
            }

            return true;
        }

        //三通匹配
        public static bool Matching(HydroThreelinkMatchingViewModel input, List<AssetsThreelinkMainVmo> threelinkVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (threelinkVmos == null || threelinkVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsThreelinkMainVmo, double>();
            foreach (var item in threelinkVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in threelinkVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in threelinkVmos)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int caliberWeight = 1;
            if (input.Caliber > 0)
            {
                foreach (var item in threelinkVmos)
                {
                    if (item.Caliber.HasValue)
                    {
                        var diff = Math.Abs(item.Caliber.Value - input.Caliber);
                        dict[item] += diff / input.Caliber * 100 * caliberWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in threelinkVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in threelinkVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var threelink = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = threelink.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = threelink.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = threelink.Material;
            }
            if (input.Caliber <= 0)
            {
                input.Caliber = threelink.Caliber ?? 0;
            }

            if (input.RunningThroughLoss <= 0)
            {
                input.MatchingRunningThroughLoss = threelink.RunThroughMinorLoss;
            }
            if (input.MatchingBranchThroughLoss <= 0)
            {
                input.MatchingBranchThroughLoss = threelink.BranchThroughMinorLoss;
            }

            return true;
        }

        //四通匹配
        public static bool Matching(HydroFourlinkMatchingViewModel input, List<AssetsFourlinkMainVmo> fourLinkVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (fourLinkVmos == null || fourLinkVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsFourlinkMainVmo, double>();
            foreach (var item in fourLinkVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in fourLinkVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in fourLinkVmos)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int caliberWeight = 1;
            if (input.Caliber > 0)
            {
                foreach (var item in fourLinkVmos)
                {
                    if (item.Caliber.HasValue)
                    {
                        var diff = Math.Abs(item.Caliber.Value - input.Caliber);
                        dict[item] += diff / input.Caliber * 100 * caliberWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in fourLinkVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in fourLinkVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var fourlink = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = fourlink.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = fourlink.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = fourlink.Material;
            }
            if (input.Caliber <= 0)
            {
                input.Caliber = fourlink.Caliber ?? 0;
            }
            if (input.MinorLoss <= 0)
            {
                input.MatchingMinorLoss = fourlink.MinorLoss;
            }

            return true;
        }

        //喷头匹配
        public static bool Matching(HydroNozzleMatchingViewModel input, List<AssetsSprinklerMainVmo> sprinklerVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (sprinklerVmos == null || sprinklerVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsSprinklerMainVmo, double>();
            foreach (var item in sprinklerVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in sprinklerVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in sprinklerVmos)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int caliberWeight = 1;
            if (input.Caliber > 0)
            {
                foreach (var item in sprinklerVmos)
                {
                    if (item.Caliber.HasValue)
                    {
                        var diff = Math.Abs(item.Caliber.Value - input.Caliber);
                        dict[item] += diff / input.Caliber * 100 * caliberWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in sprinklerVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in sprinklerVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var sprinkler = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = sprinkler.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = sprinkler.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = sprinkler.Material;
            }
            if (input.Caliber <= 0)
            {
                input.Caliber = sprinkler.Caliber ?? 0;
            }
            if (input.MinorLoss <= 0)
            {
                input.MatchingMinorLoss = sprinkler.FlowMinorLoss;
            }

            return true;
        }

        //换热器匹配
        public static bool Matching(HydroExchangerMatchingViewModel input, List<Vmo.AssetsExchangerMainVmo> allExchangerList)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (allExchangerList == null || allExchangerList.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsExchangerMainVmo, double>();
            foreach (var item in allExchangerList)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in allExchangerList)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in allExchangerList)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int diameterWeight = 1;
            if (input.Diameter > 0)
            {
                foreach (var item in allExchangerList)
                {
                    if (item.Diameter.HasValue)
                    {
                        var diff = Math.Abs(item.Diameter.Value - input.Diameter);
                        dict[item] += diff / input.Diameter * 100 * diameterWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in allExchangerList)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in allExchangerList)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var exchanger = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = exchanger.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = exchanger.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = exchanger.Material;
            }
            if (input.Diameter <= 0)
            {
                if (exchanger.Diameter.HasValue)
                {
                    input.MatchingDiameter = exchanger.Diameter.Value;
                }
            }
            if (input.MinorLoss <= 0)
            {
                input.MatchingMinorLoss = exchanger.MinorLoss;
            }
            var relationList = Task.Run(async () =>
                await BLLFactory<HStation.BLL.PhartDiagramRelation>.Instance
                .GetExByObjectTypeAndObjectID(HStation.Assets.DataType.ExchangerMain, exchanger.ID)).Result;
            if (relationList != null && relationList.Count > 0)
            {
                var relation = relationList.OrderBy(x => x.Importance).LastOrDefault();
                input.MatchingCurveDbId = relation.ID.ToString();
                var diagram = Task.Run(async () =>
                    await BLLFactory<Yw.BLL.PhartDiagramExtensions>.Instance.GetByID(relation.DiagramID)).Result;
                if (diagram != null)
                {
                    var graph = diagram.GraphList?.FirstOrDefault();
                    if (graph != null)
                    {
                        var pts = graph.GetFeatPointList();
                        input.MatchingCurveQL = pts?.Select(x => new HydroCurvePointViewModel(x.X, x.Y)).ToList();
                    }
                }
            }
            return true;
        }

        //空压机匹配
        public static bool Matching(HydroCompressorMatchingViewModel input, List<Vmo.AssetsCompressorMainVmo> allCompressorList)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (allCompressorList == null || allCompressorList.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsCompressorMainVmo, double>();
            foreach (var item in allCompressorList)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in allCompressorList)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in allCompressorList)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int diameterWeight = 1;
            if (input.Diameter > 0)
            {
                foreach (var item in allCompressorList)
                {
                    if (item.Diameter.HasValue)
                    {
                        var diff = Math.Abs(item.Diameter.Value - input.Diameter);
                        dict[item] += diff / input.Diameter * 100 * diameterWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in allCompressorList)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in allCompressorList)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var compressor = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = compressor.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = compressor.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = compressor.Material;
            }
            if (input.Diameter <= 0)
            {
                if (compressor.Diameter.HasValue)
                {
                    input.MatchingDiameter = compressor.Diameter.Value;
                }
            }
            if (input.MinorLoss <= 0)
            {
                input.MatchingMinorLoss = compressor.MinorLoss;
            }
            var relationList = Task.Run(async () =>
                await BLLFactory<HStation.BLL.PhartDiagramRelation>.Instance
                .GetExByObjectTypeAndObjectID(HStation.Assets.DataType.ExchangerMain, compressor.ID)).Result;
            if (relationList != null && relationList.Count > 0)
            {
                var relation = relationList.OrderBy(x => x.Importance).LastOrDefault();
                input.MatchingCurveDbId = relation.ID.ToString();
                var diagram = Task.Run(async () =>
                    await BLLFactory<Yw.BLL.PhartDiagramExtensions>.Instance.GetByID(relation.DiagramID)).Result;
                if (diagram != null)
                {
                    var graph = diagram.GraphList?.FirstOrDefault();
                    if (graph != null)
                    {
                        var pts = graph.GetFeatPointList();
                        input.MatchingCurveQL = pts?.Select(x => new HydroCurvePointViewModel(x.X, x.Y)).ToList();
                    }
                }
            }
            return true;
        }

        //闷头匹配
        public static bool Matching(HydroBluntheadMatchingViewModel input, List<AssetsBluntheadMainVmo> bluntheadVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (bluntheadVmos == null || bluntheadVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsBluntheadMainVmo, double>();
            foreach (var item in bluntheadVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in bluntheadVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in bluntheadVmos)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int caliberWeight = 1;
            if (input.Caliber > 0)
            {
                foreach (var item in bluntheadVmos)
                {
                    if (item.Caliber.HasValue)
                    {
                        var diff = Math.Abs(item.Caliber.Value - input.Caliber);
                        dict[item] += diff / input.Caliber * 100 * caliberWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in bluntheadVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in bluntheadVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var blunthead = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = blunthead.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = blunthead.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = blunthead.Material;
            }
            if (input.Caliber <= 0)
            {
                input.Caliber = blunthead.Caliber ?? 0;
            }
            if (input.MinorLoss < 0)
            {
                input.MatchingMinorLoss = blunthead.MinorLoss;
            }

            return true;
        }

        //水池匹配
        public static bool Matching(HydroTankMatchingViewModel input, List<AssetsTankMainVmo> tankVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (tankVmos == null || tankVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsTankMainVmo, double>();
            foreach (var item in tankVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in tankVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in tankVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in tankVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var tank = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = tank.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = tank.Name;
            }

            if (input.DN <= 0)
            {
                input.MatchingDN = tank.DN;
            }
            if (input.MinLevel <= 0)
            {
                input.MatchingMinLevel = tank.MinLevel;
            }
            input.MatchingOverFlow = tank.OverFlow;
            if (input.MinVol <= 0)
            {
                input.MatchingMinVol = tank.MinVol;
            }
            if (input.MaxLevel <= 0)
            {
                input.MatchingMaxLevel = tank.MaxLevel;
            }
            if (input.CurveDbId == null)
            {
                var list = Task.Run(async () =>
                    await new BLL.PhartDiagramRelation().GetExByObjectTypeAndObjectID(HStation.Assets.DataType.TankMain, tank.ID)).Result;
                if (list != null && list.Count > 0)
                {
                    var def = list.OrderByDescending(x => x.Importance).First();
                    input.MatchingCurveDbId = def.ID.ToString();
                    var curve = def.Diagram.GraphList[0].GetFeatPointList();
                    input.MatchingVolCurve = new List<HydroCurvePointViewModel>();
                    foreach (var item in curve)
                    {
                        input.MatchingVolCurve.Add(new HydroCurvePointViewModel(item.X, item.Y));
                    }
                }
            }
            return true;
        }

        //水表匹配
        public static bool Matching(HydroMeterMatchingViewModel input, List<AssetsMeterMainVmo> allMeterList)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (allMeterList == null || allMeterList.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsMeterMainVmo, double>();
            foreach (var item in allMeterList)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 100;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in allMeterList)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in allMeterList)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 10;
            foreach (var item in allMeterList)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var flowmeter = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = flowmeter.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = flowmeter.Name;
            }
            if (input.MinorLoss <= 0)
            {
                input.MatchingMinorLoss = flowmeter.MinorLoss;
            }

            return true;
        }

        //流量计匹配
        public static bool Matching(HydroFlowmeterMatchingViewModel input, List<Vmo.AssetsFlowmeterMainVmo> allFlowmeterList)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (allFlowmeterList == null || allFlowmeterList.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsFlowmeterMainVmo, double>();
            foreach (var item in allFlowmeterList)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 100;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in allFlowmeterList)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in allFlowmeterList)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 10;
            foreach (var item in allFlowmeterList)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var flowmeter = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = flowmeter.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = flowmeter.Name;
            }
            if (input.MinorLoss <= 0)
            {
                input.MatchingMinorLoss = flowmeter.MinorLoss;
            }

            return true;
        }

        //消火栓匹配
        public static bool Matching(HydroHydrantMatchingViewModel input, List<AssetsHydrantMainVmo> hydrantVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (hydrantVmos == null || hydrantVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsHydrantMainVmo, double>();
            foreach (var item in hydrantVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in hydrantVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in hydrantVmos)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int caliberWeight = 1;
            if (input.Caliber > 0)
            {
                foreach (var item in hydrantVmos)
                {
                    if (item.Caliber.HasValue)
                    {
                        var diff = Math.Abs(item.Caliber.Value - input.Caliber);
                        dict[item] += diff / input.Caliber * 100 * caliberWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in hydrantVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in hydrantVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var hydrant = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = hydrant.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = hydrant.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = hydrant.Material;
            }
            if (input.Caliber <= 0)
            {
                input.Caliber = hydrant.Caliber ?? 0;
            }
            if (input.MinorLoss < 0)
            {
                input.MatchingMinorLoss = hydrant.MinorLoss;
            }

            return true;
        }

        //弯头匹配
        public static bool Matching(HydroElbowMatchingViewModel input, List<Vmo.AssetsElbowMainVmo> allElbowList)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (allElbowList == null || allElbowList.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsElbowMainVmo, double>();
            foreach (var item in allElbowList)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 100;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in allElbowList)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in allElbowList)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 10;
            foreach (var item in allElbowList)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var elbow = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = elbow.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = elbow.Name;
            }
            if (input.MinorLoss <= 0 || input.MinorLoss == null)
            {
                input.MatchingMinorLoss = elbow.MinorLoss;
            }
            if (input.BendingAngle <= 0 || input.BendingAngle == null)
            {
                input.MatchingBendingAngle = elbow.Angle;
            }
            input.MatchingElbowType = (Yw.WinFrmUI.eElbowType)(int)elbow.ElbowType;
            if (input.Material == null || input.Material == string.Empty)
            {
                input.MatchingMaterial = elbow.Material;
            }
            if (input.Caliber <= 0)
            {
                input.MatchingCaliber = elbow.Caliber;
            }
            return true;
        }

        //压力表匹配
        public static bool Matching(HydroPressmeterMatchingViewModel input, List<AssetsPressmeterMainVmo> pressmeterVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (pressmeterVmos == null || pressmeterVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsPressmeterMainVmo, double>();
            foreach (var item in pressmeterVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in pressmeterVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in pressmeterVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in pressmeterVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var pressmeter = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = pressmeter.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = pressmeter.Name;
            }
            if (input.MinorLoss < 0)
            {
                input.MatchingMinorLoss = pressmeter.MinorLoss;
            }

            return true;
        }

        //过渡件匹配
        public static bool Matching(HydroTranslationMatchingViewModel input, List<AssetsTranslationMainVmo> translationVmos)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (translationVmos == null || translationVmos.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsTranslationMainVmo, double>();
            foreach (var item in translationVmos)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in translationVmos)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in translationVmos)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in translationVmos)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in translationVmos)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var translation = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = translation.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = translation.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = translation.Material;
            }
            if (input.MinorLoss < 0)
            {
                input.MatchingMinorLoss = translation.MinorLoss;
            }
            if (input.Roughness < 0)
            {
                input.MatchingRoughness = translation.Roughness;
            }
            if (input.EndDiameter < 0)
            {
                input.MatchingEndDiameter = translation.EndDiameter;
            }
            if (input.StartDiameter < 0)
            {
                input.MatchingStartDiameter = translation.StartDiameter;
            }

            return true;
        }

        //冷却器匹配
        public static bool Matching(HydroCoolingMatchingViewModel input, List<AssetsCoolingMainVmo> allCoolingList)
        {
            //输入参数验证
            if (input == null)
            {
                return false;
            }

            //数据源没有数据则没有匹配成功
            if (allCoolingList == null || allCoolingList.Count < 1)
            {
                return false;
            }

            //权重字典
            var dict = new Dictionary<AssetsCoolingMainVmo, double>();
            foreach (var item in allCoolingList)
            {
                dict.Add(item, 0);
            }

            //型号
            int modelTypeWeight = 10;
            if (!string.IsNullOrEmpty(input.ModelType))
            {
                foreach (var item in allCoolingList)
                {
                    if (!string.IsNullOrEmpty(item.Name))
                    {
                        var count = item.Name.ToLower().Intersect(input.ModelType.ToLower()).Count();
                        dict[item] += count * modelTypeWeight;
                    }
                }
            }

            //材质
            int materialWeight = 5;
            if (!string.IsNullOrEmpty(input.Material))
            {
                foreach (var item in allCoolingList)
                {
                    if (!string.IsNullOrEmpty(item.Material))
                    {
                        var count = item.Material.ToLower().Intersect(input.Material.ToLower()).Count();
                        dict[item] += count * materialWeight;
                    }
                }
            }

            //口径
            int caliberWeight = 1;
            if (input.Caliber > 0)
            {
                foreach (var item in allCoolingList)
                {
                    if (item.Caliber.HasValue)
                    {
                        var diff = Math.Abs(item.Caliber.Value - input.Caliber);
                        dict[item] += diff / input.Caliber * 100 * caliberWeight;
                    }
                }
            }

            // 关键字
            int keywordWeight = 1;
            foreach (var item in allCoolingList)
            {
                if (item.KeyWords != null && item.KeyWords.Count > 0)
                {
                    if (!string.IsNullOrEmpty(input.ModelType))
                    {
                        var count = item.KeyWords.Count(x => input.ModelType.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                    if (!string.IsNullOrEmpty(input.Material))
                    {
                        var count = item.KeyWords.Count(x => input.Material.ToLower().Contains(x.ToLower()));
                        dict[item] += count * keywordWeight;
                    }
                }
            }

            //标签
            int flagWeight = 1;
            foreach (var item in allCoolingList)
            {
                if (item.Flags != null && item.Flags.Count > 0)
                {
                    if (item.Flags.Contains(HStation.Assets.Flags.默认))
                    {
                        dict[item] += flagWeight;
                    }
                }
            }

            var cooling = dict.OrderBy(x => x.Value).LastOrDefault().Key;
            input.MatchingDbId = cooling.ID.ToString();
            if (string.IsNullOrEmpty(input.ModelType))
            {
                input.MatchingModelType = cooling.Name;
            }
            if (string.IsNullOrEmpty(input.Material))
            {
                input.MatchingMaterial = cooling.Material;
            }
            if (input.Caliber <= 0)
            {
                input.Caliber = cooling.Caliber ?? 0;
            }
            if (input.Coefficient <= 1)
            {
                input.MatchingCoefficient = cooling.Coefficient;
            }
            if (input.LowerLimit <= 0)
            {
                input.MatchingLowerLimit = cooling.LowerLimit;
            }

            return true;
        }

        /// <summary>
        /// 获取两个字符串的所有交集
        /// </summary>
        public static int GetIntersect(string str1, string str2)
        {
            if (str1 == null || str2 == null) return 0;
            return string.Join("", str1.Intersect(str2)).Count();
        }
    }
}