using SqlSugar;

namespace HStation.WinFrmUI
{
    /// <summary>
    /// 资产匹配参数辅助类
    /// </summary>
    public class AssetsMatchingParasHelper
    {

        #region 创建

        /// <summary>
        /// 创建资产自动匹配ViewModel
        /// </summary>
        public static AssetsMatchingViewModel Create(Yw.Model.HydroModelInfo hydroInfo, List<HydroCalcuResult> allCalcuResultList)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            var input = new AssetsMatchingViewModel();

            //水泵
            input.PumpMatchingList = hydroInfo.Pumps?.Select(x => Create(hydroInfo, x, allCalcuResultList)).ToList();

            //阀门
            input.ValveMatchingList = hydroInfo.Valves?.Select(x => Create(hydroInfo, x, allCalcuResultList)).ToList();

            //管道
            input.PipeMatchingList = hydroInfo.Pipes?.Select(x => Create(hydroInfo, x, allCalcuResultList)).ToList();

            //弯头
            input.ElbowMatchingList = hydroInfo.Elbows?.Select(x => Create(hydroInfo, x, allCalcuResultList)).ToList();

            //三通
            input.ThreelinkMatchingList = hydroInfo.Threelinks?.Select(x => Create(hydroInfo, x, allCalcuResultList)).ToList();

            //四通
            input.FourlinkMatchingList = hydroInfo.Fourlinks?.Select(x => Create(hydroInfo, x, allCalcuResultList)).ToList();

            return input;
        }

        /// <summary>
        /// 创建泵自动匹配ViewModel
        /// </summary>
        public static PumpMatchingViewModel Create(Yw.Model.HydroModelInfo hydroInfo, Yw.Model.HydroPumpInfo pumpInfo, List<HydroCalcuResult> allCalcuResultList)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            if (pumpInfo == null)
            {
                return default;
            }
            return new PumpMatchingViewModel(pumpInfo, hydroInfo, allCalcuResultList);
        }

        /// <summary>
        /// 创建阀门自动匹配ViewModel
        /// </summary>
        public static ValveMatchingViewModel Create(Yw.Model.HydroModelInfo hydroInfo, Yw.Model.HydroValveInfo valveInfo, List<HydroCalcuResult> allCalcuResultList)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            if (valveInfo == null)
            {
                return default;
            }
            return new ValveMatchingViewModel(valveInfo, hydroInfo, allCalcuResultList);
        }

        /// <summary>
        /// 创建管道自动匹配ViewModel
        /// </summary>
        public static PipeMatchingViewModel Create(Yw.Model.HydroModelInfo hydroInfo, Yw.Model.HydroPipeInfo pipeInfo, List<HydroCalcuResult> allCalcuResultList)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            if (pipeInfo == null)
            {
                return default;
            }
            return new PipeMatchingViewModel()
            {
                ID = pipeInfo.ID,
                Code = pipeInfo.Code,
                Name = pipeInfo.Name,
                DbLocked = pipeInfo.DbLocked,
                ModelType = pipeInfo.ModelType,
                DbId = pipeInfo.DbId,
                Diameter = pipeInfo.Diameter,
                Material = pipeInfo.Material,
                Roughness = pipeInfo.Roughness,
                MinorLoss = pipeInfo.MinorLoss,
                eAlgorithmType = HStation.Assets.eAlgorithmType.Hazen
            };
        }

        /// <summary>
        /// 创建弯头自动匹配ViewModel
        /// </summary>
        public static ElbowMatchingViewModel Create(Yw.Model.HydroModelInfo hydroInfo, Yw.Model.HydroElbowInfo elbowInfo, List<HydroCalcuResult> allCalcuResultList)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            if (elbowInfo == null)
            {
                return default;
            }
            return new ElbowMatchingViewModel()
            {
                ID = elbowInfo.ID,
                Code = elbowInfo.Code,
                Name = elbowInfo.Name,
                DbLocked = elbowInfo.DbLocked,
                ModelType = elbowInfo.ModelType,
                DbId = elbowInfo.DbId,
                Caliber = elbowInfo.Caliber,
                Material = elbowInfo.Material,
                MinorLoss = elbowInfo.MinorLoss
            };
        }

        /// <summary>
        /// 创建三通自动匹配ViewModel
        /// </summary>
        public static ThreelinkMatchingViewModel Create(Yw.Model.HydroModelInfo hydroInfo, Yw.Model.HydroThreelinkInfo threelinkInfo, List<HydroCalcuResult> allCalcuResultList)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            if (threelinkInfo == null)
            {
                return default;
            }
            return new ThreelinkMatchingViewModel()
            {
                ID = threelinkInfo.ID,
                Code = threelinkInfo.Code,
                Name = threelinkInfo.Name,
                DbLocked = threelinkInfo.DbLocked,
                ModelType = threelinkInfo.ModelType,
                DbId = threelinkInfo.DbId,
                Caliber = threelinkInfo.Caliber,
                Material = threelinkInfo.Material,
                MinorLoss = threelinkInfo.MinorLoss
            };
        }

        /// <summary>
        /// 创建四通自动匹配ViewModel
        /// </summary>
        public static FourlinkMatchingViewModel Create(Yw.Model.HydroModelInfo hydroInfo, Yw.Model.HydroFourlinkInfo fourlinkInfo, List<HydroCalcuResult> allCalcuResultList)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            if (fourlinkInfo == null)
            {
                return default;
            }
            return new FourlinkMatchingViewModel()
            {
                ID = fourlinkInfo.ID,
                Code = fourlinkInfo.Code,
                Name = fourlinkInfo.Name,
                DbLocked = fourlinkInfo.DbLocked,
                ModelType = fourlinkInfo.ModelType,
                DbId = fourlinkInfo.DbId,
                Caliber = fourlinkInfo.Caliber,
                Material = fourlinkInfo.Material,
                MinorLoss = fourlinkInfo.MinorLoss
            };
        }

        #endregion

        #region 应用

        /// <summary>
        /// 应用资产自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, AssetsMatchingViewModel output)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (output == null)
            {
                return false;
            }

            bool result = false;

            //水泵
            output.PumpMatchingList?.ForEach(x =>
            {
                if (Apply(hydroInfo, x))
                {
                    result = true;
                }
            });

            //阀门
            output.ValveMatchingList?.ForEach(x =>
            {
                if (Apply(hydroInfo, x))
                {
                    result = true;
                }
            });

            //管道
            output.PipeMatchingList?.ForEach(x =>
            {
                if (Apply(hydroInfo, x))
                {
                    result = true;
                }
            });

            //弯头
            output.ElbowMatchingList?.ForEach(x =>
            {
                if (Apply(hydroInfo, x))
                {
                    result = true;
                }
            });

            //三通
            output.ThreelinkMatchingList?.ForEach(x =>
            {
                if (Apply(hydroInfo, x))
                {
                    result = true;
                }
            });

            //四通
            output.FourlinkMatchingList?.ForEach(x =>
            {
                if (Apply(hydroInfo, x))
                {
                    result = true;
                }
            });

            return result;
        }

        /// <summary>
        /// 应用泵自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, PumpMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var pump = hydroInfo.Pumps?.Find(x => x.Code == matching.Code);
            if (pump != null)
            {
                pump.DbLocked = matching.DbLocked;
                pump.ModelType = matching.ModelType;
                pump.RatedP = matching.RatedP;
                pump.RatedQ = matching.RatedQ;
                pump.RatedH = matching.RatedH;
                pump.RatedN = matching.RatedN;
                pump.RatedHz = matching.RatedHz;
                pump.SpeedRatio = Math.Round(matching.CurrentHz / matching.RatedHz, 1);

                if (!pump.DbLocked)
                {
                    if (!string.IsNullOrEmpty(matching.MatchingModelType))
                    {
                        pump.ModelType = matching.MatchingModelType;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingDbId))
                    {
                        pump.DbId = matching.MatchingDbId;
                    }
                    if (matching.MatchingRatedP.HasValue)
                    {
                        pump.RatedP = matching.MatchingRatedP.Value;
                    }
                    if (matching.MatchingRatedQ.HasValue)
                    {
                        pump.RatedQ = matching.MatchingRatedQ.Value;
                    }
                    if (matching.MatchingRatedH.HasValue)
                    {
                        pump.RatedH = matching.MatchingRatedH.Value;
                    }
                    if (matching.MatchingRatedN.HasValue)
                    {
                        pump.RatedN = matching.MatchingRatedN.Value;
                    }

                    if (!string.IsNullOrEmpty(matching.MatchingCurveDbId))
                    {
                        //流量扬程曲线
                        var curveqh = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQH);
                        if (curveqh == null)
                        {
                            curveqh = new Yw.Model.HydroCurveInfo();
                            curveqh.Catalog = Yw.Hydro.ParterCatalog.Curve;
                            curveqh.Code = Yw.Untity.UniqueHelper.CreateFromFirst("curve", hydroInfo.GetAllParterCodes());
                            curveqh.Name = "匹配";
                            curveqh.ModelType = string.Empty;
                            curveqh.DbLocked = false;
                            curveqh.DbId = matching.MatchingCurveDbId;
                            curveqh.CurveType = Yw.WinFrmUI.HydroCurve.PumpQH;
                            curveqh.CurveData = matching.MatchingCurveQH?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            if (hydroInfo.Curves == null)
                            {
                                hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
                            }
                            hydroInfo.Curves.Add(curveqh);
                            pump.CurveQH = curveqh.Code;
                        }
                        else
                        {
                            if (!curveqh.DbLocked)
                            {
                                curveqh.DbId = matching.MatchingCurveDbId;
                                curveqh.CurveData = matching.MatchingCurveQH?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            }
                        }

                        //流量功率曲线
                        var curveqp = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQP);
                        if (curveqp == null)
                        {
                            curveqp = new Yw.Model.HydroCurveInfo();
                            curveqp.Catalog = Yw.Hydro.ParterCatalog.Curve;
                            curveqp.Code = Yw.Untity.UniqueHelper.CreateFromFirst("curve", hydroInfo.GetAllParterCodes());
                            curveqp.Name = "匹配";
                            curveqp.ModelType = string.Empty;
                            curveqp.DbLocked = false;
                            curveqp.DbId = matching.MatchingCurveDbId;
                            curveqp.CurveType = Yw.WinFrmUI.HydroCurve.PumpQP;
                            curveqp.CurveData = matching.MatchingCurveQP?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            if (hydroInfo.Curves == null)
                            {
                                hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
                            }
                            hydroInfo.Curves.Add(curveqp);
                            pump.CurveQP = curveqp.Code;
                        }
                        else
                        {
                            if (!curveqp.DbLocked)
                            {
                                curveqp.DbId = matching.MatchingCurveDbId;
                                curveqp.CurveData = matching.MatchingCurveQP?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            }
                        }

                        //流量效率曲线
                        var curveqe = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQE);
                        if (curveqe == null)
                        {
                            curveqe = new Yw.Model.HydroCurveInfo();
                            curveqe.Catalog = Yw.Hydro.ParterCatalog.Curve;
                            curveqe.Code = Yw.Untity.UniqueHelper.CreateFromFirst("curve", hydroInfo.GetAllParterCodes());
                            curveqe.Name = "匹配";
                            curveqe.ModelType = string.Empty;
                            curveqe.DbLocked = false;
                            curveqe.DbId = matching.MatchingCurveDbId;
                            curveqe.CurveType = Yw.WinFrmUI.HydroCurve.PumpQE;
                            curveqe.CurveData = matching.MatchingCurveQE?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            if (hydroInfo.Curves == null)
                            {
                                hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
                            }
                            hydroInfo.Curves.Add(curveqe);
                            pump.CurveQE = curveqe.Code;
                        }
                        else
                        {
                            if (!curveqe.DbLocked)
                            {
                                curveqe.DbId = matching.MatchingCurveDbId;
                                curveqe.CurveData = matching.MatchingCurveQE?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            }
                        }

                    }

                    result = true;
                }
            }

            return result;
        }

        /// <summary>
        /// 应用阀门自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, ValveMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var valve = hydroInfo.Valves?.Find(x => x.Code == matching.Code);
            if (valve != null)
            {
                valve.DbLocked = matching.DbLocked;
                valve.ModelType = matching.ModelType;
                valve.Material = matching.Material;
                valve.Diameter = matching.Diameter;
                valve.MinorLoss = matching.MinorLoss;
                switch (matching.ValveType)
                {
                    case HStation.Assets.eValveType.PBV: valve.ValveType = Yw.Hydro.ValveType.PBV; break;
                    case HStation.Assets.eValveType.PRV: valve.ValveType = Yw.Hydro.ValveType.PRV; break;
                    case HStation.Assets.eValveType.PSV: valve.ValveType = Yw.Hydro.ValveType.PSV; break;
                    case HStation.Assets.eValveType.TCV: valve.ValveType = Yw.Hydro.ValveType.TCV; break;
                    case HStation.Assets.eValveType.FCV: valve.ValveType = Yw.Hydro.ValveType.FCV; break;
                    case HStation.Assets.eValveType.GPV: valve.ValveType = Yw.Hydro.ValveType.GPV; break;
                    case HStation.Assets.eValveType.CV: valve.ValveType = Yw.Hydro.ValveType.CV; break;
                    default: break;
                }
                valve.ValveSetting = matching.ValveSetting;

                if (!valve.DbLocked)
                {
                    if (!string.IsNullOrEmpty(matching.MatchingDbId))
                    {
                        valve.DbId = matching.MatchingDbId;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingModelType))
                    {
                        valve.ModelType = matching.MatchingModelType;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingMaterial))
                    {
                        valve.Material = matching.MatchingMaterial;
                    }
                    if (matching.MatchingDiameter.HasValue)
                    {
                        valve.Diameter = matching.MatchingDiameter.Value;
                    }
                    if (matching.MatchingMinorLoss.HasValue)
                    {
                        valve.MinorLoss = matching.MatchingMinorLoss.Value;
                    }
                    if (matching.MatchingValveType.HasValue)
                    {
                        switch (matching.MatchingValveType.Value)
                        {
                            case HStation.Assets.eValveType.PBV: valve.ValveType = Yw.Hydro.ValveType.PBV; break;
                            case HStation.Assets.eValveType.PRV: valve.ValveType = Yw.Hydro.ValveType.PRV; break;
                            case HStation.Assets.eValveType.PSV: valve.ValveType = Yw.Hydro.ValveType.PSV; break;
                            case HStation.Assets.eValveType.TCV: valve.ValveType = Yw.Hydro.ValveType.TCV; break;
                            case HStation.Assets.eValveType.FCV: valve.ValveType = Yw.Hydro.ValveType.FCV; break;
                            case HStation.Assets.eValveType.GPV: valve.ValveType = Yw.Hydro.ValveType.GPV; break;
                            case HStation.Assets.eValveType.CV: valve.ValveType = Yw.Hydro.ValveType.CV; break;
                            default: break;
                        }
                    }
                    switch (valve.ValveType)
                    {
                        case Yw.Hydro.ValveType.PSV:
                            {
                                if (!string.IsNullOrEmpty(matching.MatchingValveSetting))
                                {
                                    valve.ValveSetting = matching.MatchingValveSetting;
                                }
                            }
                            break;
                        case Yw.Hydro.ValveType.PBV:
                            {
                                if (!string.IsNullOrEmpty(matching.MatchingValveSetting))
                                {
                                    valve.ValveSetting = matching.MatchingValveSetting;
                                }
                            }
                            break;
                        case Yw.Hydro.ValveType.PRV:
                            {
                                if (!string.IsNullOrEmpty(matching.MatchingValveSetting))
                                {
                                    valve.ValveSetting = matching.MatchingValveSetting;
                                }
                            }
                            break;
                        case Yw.Hydro.ValveType.FCV:
                            {
                                if (!string.IsNullOrEmpty(matching.MatchingValveSetting))
                                {
                                    valve.ValveSetting = matching.MatchingValveSetting;
                                }
                            }
                            break;
                        case Yw.Hydro.ValveType.TCV:
                            {
                                if (!string.IsNullOrEmpty(matching.MatchingCurveDbId))
                                {
                                    //阀门开度损失系数曲线
                                    var curveol = hydroInfo.Curves?.Find(x => x.Code == valve.ValveSetting);
                                    if (curveol == null)
                                    {
                                        curveol = new Yw.Model.HydroCurveInfo();
                                        curveol.Catalog = Yw.Hydro.ParterCatalog.Curve;
                                        curveol.Code = Yw.Untity.UniqueHelper.CreateFromFirst("curve", hydroInfo.GetAllParterCodes());
                                        curveol.Name = "匹配";
                                        curveol.ModelType = valve.ModelType;
                                        curveol.DbLocked = false;
                                        curveol.DbId = matching.MatchingCurveDbId;
                                        curveol.CurveType = Yw.WinFrmUI.HydroCurve.ValveOL;
                                        curveol.CurveData = matching.MatchingCurveOL?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                                        if (hydroInfo.Curves == null)
                                        {
                                            hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
                                        }
                                        hydroInfo.Curves.Add(curveol);
                                        valve.ValveSetting = curveol.Code;
                                    }
                                    else
                                    {
                                        if (!curveol.DbLocked)
                                        {
                                            curveol.DbId = matching.MatchingCurveDbId;
                                            curveol.CurveData = matching.MatchingCurveOL?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                                        }
                                    }
                                }
                            }
                            break;
                        case Yw.Hydro.ValveType.GPV:
                            {
                                if (!string.IsNullOrEmpty(matching.MatchingCurveDbId))
                                {
                                    //阀门开度损失系数曲线
                                    var curveql = hydroInfo.Curves?.Find(x => x.Code == valve.ValveSetting);
                                    if (curveql == null)
                                    {
                                        curveql = new Yw.Model.HydroCurveInfo();
                                        curveql.Catalog = Yw.Hydro.ParterCatalog.Curve;
                                        curveql.Code = Yw.Untity.UniqueHelper.CreateFromFirst("curve", hydroInfo.GetAllParterCodes());
                                        curveql.Name = "匹配";
                                        curveql.ModelType = valve.ModelType;
                                        curveql.DbLocked = false;
                                        curveql.DbId = matching.MatchingCurveDbId;
                                        curveql.CurveType = Yw.WinFrmUI.HydroCurve.ValveOL;
                                        curveql.CurveData = matching.MatchingCurveQL?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                                        if (hydroInfo.Curves == null)
                                        {
                                            hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
                                        }
                                        hydroInfo.Curves.Add(curveql);
                                        valve.ValveSetting = curveql.Code;
                                    }
                                    else
                                    {
                                        if (!curveql.DbLocked)
                                        {
                                            curveql.DbId = matching.MatchingCurveDbId;
                                            curveql.CurveData = matching.MatchingCurveQL?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                                        }
                                    }
                                }
                            }
                            break;
                        case Yw.Hydro.ValveType.CV:
                            {

                            }
                            break;
                    }

                    result = true;
                }
            }
            return result;
        }

        /// <summary>
        /// 应用管道自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, PipeMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var pipe = hydroInfo.Pipes?.Find(x => x.Code == matching.Code);
            if (pipe != null)
            {
                pipe.DbLocked = matching.DbLocked;
                pipe.ModelType = matching.ModelType;
                pipe.Diameter = matching.Diameter;
                pipe.Material = matching.Material;
                pipe.Roughness = matching.Roughness;
                pipe.MinorLoss = matching.MinorLoss;

                if (!pipe.DbLocked)
                {
                    if (!string.IsNullOrEmpty(matching.MatchingModelType))
                    {
                        pipe.ModelType = matching.MatchingModelType;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingDbId))
                    {
                        pipe.DbId = matching.MatchingDbId;
                    }
                    if (matching.MatchingDiameter.HasValue)
                    {
                        pipe.Diameter = matching.MatchingDiameter.Value;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingMaterial))
                    {
                        pipe.Material = matching.MatchingMaterial;
                    }
                    if (matching.MatchingRoughness.HasValue)
                    {
                        pipe.Roughness = matching.MatchingRoughness.Value;
                    }
                    if (matching.MatchingMinorLoss.HasValue)
                    {
                        pipe.MinorLoss = matching.MatchingMinorLoss.Value;
                    }

                    result = true;
                }
            }
            return result;
        }

        /// <summary>
        /// 应用弯头自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, ElbowMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var elbow = hydroInfo.Elbows?.Find(x => x.Code == matching.Code);
            if (elbow != null)
            {
                elbow.DbLocked = matching.DbLocked;
                elbow.ModelType = matching.ModelType;
                elbow.Caliber = matching.Caliber;
                elbow.Material = matching.Material;
                elbow.MinorLoss = matching.MinorLoss;

                if (!elbow.DbLocked)
                {
                    if (!string.IsNullOrEmpty(matching.MatchingModelType))
                    {
                        elbow.ModelType = matching.MatchingModelType;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingDbId))
                    {
                        elbow.DbId = matching.MatchingDbId;
                    }
                    if (matching.MatchingCaliber.HasValue)
                    {
                        elbow.Caliber = matching.MatchingCaliber.Value;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingMaterial))
                    {
                        elbow.Material = matching.MatchingMaterial;
                    }
                    if (matching.MatchingMinorLoss.HasValue)
                    {
                        elbow.MinorLoss = matching.MatchingMinorLoss.Value;
                    }

                    result = true;
                }
            }
            return result;
        }

        /// <summary>
        /// 应用三通自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, ThreelinkMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var threelink = hydroInfo.Threelinks?.Find(x => x.Code == matching.Code);
            if (threelink != null)
            {
                threelink.DbLocked = matching.DbLocked;
                threelink.ModelType = matching.ModelType;
                threelink.Caliber = matching.Caliber;
                threelink.Material = matching.Material;
                threelink.MinorLoss = matching.MinorLoss;

                if (!threelink.DbLocked)
                {
                    if (!string.IsNullOrEmpty(matching.MatchingModelType))
                    {
                        threelink.ModelType = matching.MatchingModelType;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingDbId))
                    {
                        threelink.DbId = matching.MatchingDbId;
                    }
                    if (matching.MatchingCaliber.HasValue)
                    {
                        threelink.Caliber = matching.MatchingCaliber.Value;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingMaterial))
                    {
                        threelink.Material = matching.MatchingMaterial;
                    }
                    if (matching.MatchingMinorLoss.HasValue)
                    {
                        threelink.MinorLoss = matching.MatchingMinorLoss.Value;
                    }

                    result = true;
                }
            }
            return result;
        }

        /// <summary>
        /// 应用四通自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, FourlinkMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var fourlink = hydroInfo.Fourlinks?.Find(x => x.Code == matching.Code);
            if (fourlink != null)
            {
                fourlink.DbLocked = matching.DbLocked;
                fourlink.ModelType = matching.ModelType;
                fourlink.Caliber = matching.Caliber;
                fourlink.Material = matching.Material;
                fourlink.MinorLoss = matching.MinorLoss;

                if (!fourlink.DbLocked)
                {
                    if (!string.IsNullOrEmpty(matching.MatchingModelType))
                    {
                        fourlink.ModelType = matching.MatchingModelType;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingDbId))
                    {
                        fourlink.DbId = matching.MatchingDbId;
                    }
                    if (matching.MatchingCaliber.HasValue)
                    {
                        fourlink.Caliber = matching.MatchingCaliber.Value;
                    }
                    if (!string.IsNullOrEmpty(matching.MatchingMaterial))
                    {
                        fourlink.Material = matching.MatchingMaterial;
                    }
                    if (matching.MatchingMinorLoss.HasValue)
                    {
                        fourlink.MinorLoss = matching.MatchingMinorLoss.Value;
                    }

                    result = true;
                }
            }
            return result;
        }

        #endregion

        //获取所有编码列表
        private static List<string> GetAllCodeList(Yw.Model.HydroModelInfo hydroInfo)
        {
            if (hydroInfo == null)
            {
                return default;
            }
            var allParterList = hydroInfo.GetAllParters();
            return allParterList?.Select(x => x.Code).Distinct().ToList();
        }

    }
}