using IStation.Epanet;
using IStation.Epanet.Enums;
using System.Text;

namespace IStation.Test.Init
{
    /// <summary>
    /// 调度分析辅助类
    /// </summary>
    public   class AnalysisDeviationHelper
    {
        private static string _model_file = System.IO.Path.Combine(
        Settings.ParasHelper.LocalFile.DataFolderDirectory,
        "ch2_v3_ 20240801(Clear).inp");

        private static IStation.Service.AnalysisDeviation _service_analysis_deviation = new Service.AnalysisDeviation();

        public static bool Ana()
        {
            _service_analysis_deviation.DeleteAll();
            var day_value_list  =Test.Init.DayValueHelper.GetDayValues();
            if (day_value_list == null || !day_value_list.Any())
            {
                return false;
            }
            OutScadaScheduleVmList(day_value_list, out List<Station1ScadaSchedule> all_station1_scada_schedule_list, out List<Station2ScadaSchedule> all_station2_scada_schedule_list);
            var station1_flow_range_correction_factor_list = AnaStation1CorrectionFactor(all_station1_scada_schedule_list);
            var station2_flow_range_correction_factor_list = AnaStation2CorrectionFactor(all_station2_scada_schedule_list);

            var list = new List<Model.AnalysisDeviation>(); 
            foreach (var item in station1_flow_range_correction_factor_list)
            {
                var model = new Model.AnalysisDeviation();
                model.RunFlags = Yw.Untity.IntListHelper.ToList(item.Item1);
                model.RunCount = model.RunFlags.Count;
                model.MinFlow = item.Item2;
                model.MaxFlow = item.Item3;
                model.CurveDeviation = item.Item4;
                model.ModelDeviation = item.Item5;
                model.DeviationAccuracy = 0;
                list.Add(model);
            }

            foreach (var item in station2_flow_range_correction_factor_list)
            {
                var model = new Model.AnalysisDeviation();
                model.RunFlags = Yw.Untity.IntListHelper.ToList(item.Item1);
                model.RunCount = model.RunFlags.Count;
                model.MinFlow = item.Item2;
                model.MaxFlow = item.Item3;
                model.CurveDeviation = item.Item4;
                model.ModelDeviation = item.Item5;
                model.DeviationAccuracy = 0;
                list.Add(model);
            }

            var bol = _service_analysis_deviation.Inserts(list);
            if (!bol)
            {
                throw (new Exception("失败！"));
            }
            return bol;
        }




        public static void OutScadaScheduleVmList
            (List<DayValue> day_value_list,
            out List<Station1ScadaSchedule> all_station1_scada_schedule_list,
            out List<Station2ScadaSchedule> all_station2_scada_schedule_list)
        {
            all_station1_scada_schedule_list = new List<Station1ScadaSchedule>();
            all_station2_scada_schedule_list = new List<Station2ScadaSchedule>();
            if (day_value_list == null || !day_value_list.Any())
            {
                return;
            }
            var limited_min_flow = 100;
            var limited_speed_ratio = 0.1;
            foreach (var day_value in day_value_list)
            {
                var time_value_list = day_value.TimeValueList;
                foreach (var time_value in time_value_list)
                {
                    var time = time_value.Time;
                    var scada_value_dict = time_value.Value;

                    var vm1 = new Station1ScadaSchedule();
                    vm1.Time = time;
                    vm1.R1 = scada_value_dict["R1"];
                    vm1.R2 = scada_value_dict["R2"];
                    vm1.R3 = scada_value_dict["R3"];

                    vm1.JD1P = scada_value_dict["SPJD1"];
                    vm1.JD2P = scada_value_dict["SPJD2"];
                    vm1.JD3P = scada_value_dict["SPJD3"];
                    vm1.Pump11P = scada_value_dict["SPPump11"];
                    vm1.Pump12P = scada_value_dict["SPPump12"];
                    vm1.Pump13P = scada_value_dict["SPPump13"];
                    vm1.Pump14P = scada_value_dict["SPPump14"];
                    vm1.Pump15P = scada_value_dict["SPPump15"];
                    vm1.Pump16P = scada_value_dict["SPPump16"];
                    vm1.Pump17P = scada_value_dict["SPPump17"];
                    vm1.Pump18P = scada_value_dict["SPPump18"];

                    vm1.JD1F = scada_value_dict["SFJD1"];
                    vm1.JD2F = scada_value_dict["SFJD2"];
                    vm1.JD3F = scada_value_dict["SFJD3"];

                    vm1.Pump11 = scada_value_dict["Pump11"];
                    vm1.Pump12 = scada_value_dict["Pump12"];
                    vm1.Pump13 = scada_value_dict["Pump13"];
                    vm1.Pump14 = scada_value_dict["Pump14"];
                    vm1.Pump15 = scada_value_dict["Pump15"];
                    vm1.Pump16 = scada_value_dict["Pump16"];
                    vm1.Pump17 = scada_value_dict["Pump17"];
                    vm1.Pump18 = scada_value_dict["Pump18"];

                    var power11 = scada_value_dict["Power11"];
                    var power12 = scada_value_dict["Power12"];
                    var power13 = scada_value_dict["Power13"];
                    var power14 = scada_value_dict["Power14"];
                    var power15 = scada_value_dict["Power15"];
                    var power16 = scada_value_dict["Power16"];
                    var power17 = scada_value_dict["Power17"];
                    var power18 = scada_value_dict["Power18"];

                    vm1.TotalPower = power11 + power12 + power13 + power14 + power15 + power16 + power17 + power18;

                    vm1.Pump11 = vm1.Pump11 < limited_speed_ratio ? 0 : vm1.Pump11;
                    vm1.Pump12 = vm1.Pump12 < limited_speed_ratio ? 0 : vm1.Pump12;
                    vm1.Pump13 = vm1.Pump13 < limited_speed_ratio ? 0 : vm1.Pump13;
                    vm1.Pump14 = vm1.Pump14 < limited_speed_ratio ? 0 : vm1.Pump14;
                    vm1.Pump15 = vm1.Pump15 < limited_speed_ratio ? 0 : vm1.Pump15;
                    vm1.Pump16 = vm1.Pump16 < limited_speed_ratio ? 0 : vm1.Pump16;
                    vm1.Pump17 = vm1.Pump17 < limited_speed_ratio ? 0 : vm1.Pump17;
                    vm1.Pump18 = vm1.Pump18 < limited_speed_ratio ? 0 : vm1.Pump18;

                    var vm2 = new Station2ScadaSchedule();
                    vm2.Time = time;
                    vm2.RPump21 = scada_value_dict["RPump21"];
                    vm2.RPump22 = scada_value_dict["RPump22"];
                    vm2.RPump23 = scada_value_dict["RPump23"];
                    vm2.RPump24 = scada_value_dict["RPump24"];
                    vm2.RPump25 = scada_value_dict["RPump25"];
                    vm2.RPump26 = scada_value_dict["RPump26"];
                    vm2.RPump27 = scada_value_dict["RPump27"];

                    vm2.DN2400P = scada_value_dict["SPDN2400"];
                    vm2.DN2700P = scada_value_dict["SPDN2700"];
                    vm2.Pump21P = scada_value_dict["SPPump21"];
                    vm2.Pump22P = scada_value_dict["SPPump22"];
                    vm2.Pump23P = scada_value_dict["SPPump23"];
                    vm2.Pump24P = scada_value_dict["SPPump24"];
                    vm2.Pump25P = scada_value_dict["SPPump25"];
                    vm2.Pump26P = scada_value_dict["SPPump26"];
                    vm2.Pump27P = scada_value_dict["SPPump27"];

                    vm2.DN2700F = scada_value_dict["SFDN2700"];
                    vm2.DN2400F = scada_value_dict["SFDN2400"];
                    vm2.Pump21F = scada_value_dict["SFPump21"];
                    vm2.Pump22F = scada_value_dict["SFPump22"];
                    vm2.Pump23F = scada_value_dict["SFPump23"];
                    vm2.Pump24F = scada_value_dict["SFPump24"];
                    vm2.Pump25F = scada_value_dict["SFPump25"];
                    vm2.Pump26F = scada_value_dict["SFPump26"];
                    vm2.Pump27F = scada_value_dict["SFPump27"];

                    vm2.Pump21 = scada_value_dict["Pump21"];
                    vm2.Pump22 = scada_value_dict["Pump22"];
                    vm2.Pump23 = scada_value_dict["Pump23"];
                    vm2.Pump24 = scada_value_dict["Pump24"];
                    vm2.Pump25 = scada_value_dict["Pump25"];
                    vm2.Pump26 = scada_value_dict["Pump26"];
                    vm2.Pump27 = scada_value_dict["Pump27"];

                    var power21 = scada_value_dict["Power21"];
                    var power22 = scada_value_dict["Power22"];
                    var power23 = scada_value_dict["Power23"];
                    var power24 = scada_value_dict["Power24"];
                    var power25 = scada_value_dict["Power25"];
                    var power26 = scada_value_dict["Power26"];
                    var power27 = scada_value_dict["Power27"];

                    vm2.TotalPower = power21 + power22 + power23 + power24 + power25 + power26 + power27;

                    vm2.Pump21 = vm2.Pump21 < limited_speed_ratio ? 0 : vm2.Pump21;
                    vm2.Pump22 = vm2.Pump22 < limited_speed_ratio ? 0 : vm2.Pump22;
                    vm2.Pump23 = vm2.Pump23 < limited_speed_ratio ? 0 : vm2.Pump23;
                    vm2.Pump24 = vm2.Pump24 < limited_speed_ratio ? 0 : vm2.Pump24;
                    vm2.Pump25 = vm2.Pump25 < limited_speed_ratio ? 0 : vm2.Pump25;
                    vm2.Pump26 = vm2.Pump26 < limited_speed_ratio ? 0 : vm2.Pump26;
                    vm2.Pump27 = vm2.Pump27 < limited_speed_ratio ? 0 : vm2.Pump27;

                    if (vm1.JD1F < limited_min_flow || vm1.JD2F < limited_min_flow || vm1.JD3F < limited_min_flow)
                    {
                        continue;
                    }

                    if (vm2.DN2400F < limited_min_flow || vm2.DN2700F < limited_min_flow)
                    {
                        continue;
                    }

                    vm1.Sum();
                    vm2.Sum();
                    all_station1_scada_schedule_list.Add(vm1);
                    all_station2_scada_schedule_list.Add(vm2);
                }
            }
        }

        #region Station1
        private static List<Tuple<string, double, double, Dictionary<int, double>, Dictionary<int, double>>> AnaStation1CorrectionFactor(List<Station1ScadaSchedule> all_station_scada_schedule_list)
        {
            if (all_station_scada_schedule_list == null || !all_station_scada_schedule_list.Any())
            {
                return default;
            }

            #region init

            var flow_id_mapping_dict = new Dictionary<string, string>()
            {
                {"Pjd1","SFJD1"},
                {"Pjd2","SFJD2"},
                {"Pjd3","SFJD3"}
            };
            var pressure_id_mapping_dict = new Dictionary<string, string>()
            {
                {"Jjd1","SPJD1"},
                {"Jjd2","SPJD2"},
                {"Jjd3","SPJD3"},

                {"Jpump11","SPPump11"},
                {"Jpump12","SPPump12"},
                {"Jpump13","SPPump13"},
                {"Jpump14","SPPump14"},
                {"Jpump15","SPPump15"},
                {"Jpump16","SPPump16"},
                {"Jpump17","SPPump17"},
                {"Jpump18","SPPump18"}
            };

            var flag_mapping_dict = new Dictionary<string, int>(){
                { "SPPump11",GlobalHelper.Flag11},
                { "SPPump12",GlobalHelper.Flag12},
                { "SPPump13",GlobalHelper.Flag13},
                { "SPPump14",GlobalHelper.Flag14},
                { "SPPump15",GlobalHelper.Flag15},
                { "SPPump16",GlobalHelper.Flag16},
                { "SPPump17",GlobalHelper.Flag17},
                { "SPPump18",GlobalHelper.Flag18}
            };
            var pumps = new IStation.Service.Station().Get().Station2;
            #endregion

            var list = new List<Tuple<string, double, double, List<Station1ScadaSchedule>>>();
            var minQ = 0;
            var maxQ = 40000;
            var spaceQ = 2500;
            for (int currentMinQ = minQ; currentMinQ <= maxQ; currentMinQ += spaceQ)
            {
                var currentMaxQ = currentMinQ + spaceQ;
                var station_scada_schedule_list = all_station_scada_schedule_list
                      .Where(x => x.TotalFlow >= currentMinQ && x.TotalFlow <= currentMaxQ)
                      .ToList();
                if (station_scada_schedule_list == null || !station_scada_schedule_list.Any())
                    continue;

                var station_scada_schedule_group = station_scada_schedule_list.GroupBy(x => x.RunFlags);
                foreach (var item in station_scada_schedule_group)
                {
                    var run_flags = item.Key;
                    list.Add(new(run_flags, currentMinQ, currentMaxQ, item.ToList()));
                }
            }

            var scada_run_flags_head_avg_diff_dict_list = new List<Tuple<string, double, double, Dictionary<int, double>, Dictionary<int, double>>>();
            foreach (var item in list)
            {
                var run_flags = item.Item1;
                var min_flow = item.Item2;
                var max_flow = item.Item3;
                var station_scada_schedule_list = item.Item4;
                var flag_head_avg_diff_dict = GetScadaFlagHeadAvgDiffDict(pumps, station_scada_schedule_list);
                var model_head_avg_diff_dict = GetModelFlagHeadAvgDiffDict(pumps, flag_mapping_dict, station_scada_schedule_list);
                scada_run_flags_head_avg_diff_dict_list.Add(new(run_flags, min_flow, max_flow, flag_head_avg_diff_dict, model_head_avg_diff_dict));
            }

            return scada_run_flags_head_avg_diff_dict_list;
        }

        private static Dictionary<string, string> _pump_pressure_id_mapping_dict1 = new()
            {
                {"Jpump11","SPPump11"},
                {"Jpump12","SPPump12"},
                {"Jpump13","SPPump13"},
                {"Jpump14","SPPump14"},
                {"Jpump15","SPPump15"},
                {"Jpump16","SPPump16"},
                {"Jpump17","SPPump17"},
                {"Jpump18","SPPump18"},
        };

        public static Dictionary<int, double> GetModelFlagHeadAvgDiffDict
            (List<Model.Pump> pumps,
            Dictionary<string, int> flag_mapping_dict,
            List<Station1ScadaSchedule> station_scada_schedule_list)
        {
            if (station_scada_schedule_list == null || !station_scada_schedule_list.Any())
                return default;

            var err = EpanetMethods.ENopen(_model_file, "", "");
            if (err != ErrorCode.Ok)
                return default;

            err = EpanetMethods.ENopenH();
            if (err != ErrorCode.Ok)
                return default;

            var multi_tag_head_diff_list = new List<Tuple<string, double>>();
            var model_id_build = new StringBuilder(31);
            foreach (var station_scada_schedule in station_scada_schedule_list)
            {
                var pattern_init = true;
                var pattern_dict = station_scada_schedule.ToModelPatternDict();
                var scada_dict = station_scada_schedule.ToModelScadaDict();
                var pump_dict = station_scada_schedule.ToModelPumpDict();
                foreach (var pattern in pattern_dict)
                {
                    var pattern_id = pattern.Key;
                    var pattern_factor_array = pattern.Value;
                    var pattern_factor_array_count = pattern_factor_array.Length == 0 ? 1 : pattern_factor_array.Length;
                    err = EpanetMethods.ENgetpatternindex(pattern_id, out int pattern_index);
                    if (err != ErrorCode.Ok)
                    {
                        pattern_init = false;
                        continue;
                    }
                    err = EpanetMethods.ENsetpattern(pattern_index, pattern_factor_array, pattern_factor_array_count);
                    if (err != ErrorCode.Ok)
                    {
                        pattern_init = false;
                        continue;
                    }
                }
                if (!pattern_init)
                    continue;

                EpanetMethods.ENinitH(0);
                EpanetMethods.ENrunH(out _);
                EpanetMethods.ENgetcount(CountType.Node, out int node_count);

                for (int node_index = 1; node_index <= node_count; node_index++)
                {
                    if (EpanetMethods.ENgetnodeid(node_index, model_id_build) != ErrorCode.Ok)
                        continue;
                    var model_id = model_id_build.ToString();
                    if (_pump_pressure_id_mapping_dict1.ContainsKey(model_id))
                    {
                        var scada_id = _pump_pressure_id_mapping_dict1[model_id];
                        if (!(pump_dict[scada_id] > 0))
                        {
                            continue;
                        }
                        EpanetMethods.ENgetnodevalue(node_index, NodeValue.Head, out float model_head);
                        var scada_head = scada_dict[scada_id];
                        var head_diff = model_head - scada_head;
                        multi_tag_head_diff_list.Add(new(scada_id, head_diff));
                    }
                }
            }
            EpanetMethods.ENcloseH();
            EpanetMethods.ENclose();


            var tag_head_diff_list_group = multi_tag_head_diff_list.GroupBy(x => x.Item1).OrderBy(x => x.Key);
            var flag_head_avg_diff_dict = new Dictionary<int, double>();
            foreach (var item in tag_head_diff_list_group)
            {
                var flag = flag_mapping_dict[item.Key];
                var head_diff_avg = item.Average(x => x.Item2);
                flag_head_avg_diff_dict.Add(flag, head_diff_avg);
            }

            return flag_head_avg_diff_dict;
        }

        /// <summary>
        /// 无法修正曲线
        /// </summary> 
        public static Dictionary<int, double> GetScadaFlagHeadAvgDiffDict(List<Model.Pump> pumps, List<Station1ScadaSchedule> station_scada_schedule_list)
        {
            if (station_scada_schedule_list == null || !station_scada_schedule_list.Any())
                return default;

            var multi_flag_head_diff_list = new List<Tuple<int, double>>();
            foreach (var station_scada_schedule in station_scada_schedule_list)
            {
                var time = station_scada_schedule.Time;
                var flag_inlet_water_level_dict = station_scada_schedule.ToFlagInletWaterLevelDict();
                var flag_rpm_dict = station_scada_schedule.ToFlagRpmDict();
                var flag_head_dict = station_scada_schedule.ToFlagHeadDict();

                foreach (var item in flag_rpm_dict)
                {
                    var flag = item.Key;
                    var pump = pumps.Find(x => x.Flag == flag);
                    if (pump == null)
                        continue;
                     
                    var head_diff = 0;
                    multi_flag_head_diff_list.Add(new(flag, head_diff));
                }
            }

            var flag_head_diff_list_group = multi_flag_head_diff_list.GroupBy(x => x.Item1);
            var flag_head_avg_diff_dict = new Dictionary<int, double>();
            foreach (var item in flag_head_diff_list_group)
            {
                var flag = item.Key;
                var head_diff_avg = item.Average(x => x.Item2);
                flag_head_avg_diff_dict.Add(flag, head_diff_avg);
            }

            return flag_head_avg_diff_dict;
        }


        #endregion

        #region Station2

        private static List<Tuple<string, double, double, Dictionary<int, double>, Dictionary<int, double>>> AnaStation2CorrectionFactor(List<Station2ScadaSchedule> all_station_scada_schedule_list)
        {
            if (all_station_scada_schedule_list == null || !all_station_scada_schedule_list.Any())
            {
                return default;
            }

            #region init

            var flow_id_mapping_dict = new Dictionary<string, string>()
            {
                {"Pdn2400","SFDN2400"},
                {"Pdn2700","SFDN2700"},
                {"Ppump21","SFPump21"},
                {"Ppump22","SFPump22"},
                {"Ppump23","SFPump23"},
                {"Ppump24","SFPump24"},
                {"Ppump25","SFPump25"},
                {"Ppump26","SFPump26"},
                {"Ppump27","SFPump27"}
            };
            var pressure_id_mapping_dict = new Dictionary<string, string>()
            {
                {"Jdn2400","SPDN2400"},
                {"Jdn2700","SPDN2700"},
                {"Jpump21","SPPump21"},
                {"Jpump22","SPPump22"},
                {"Jpump23","SPPump23"},
                {"Jpump24","SPPump24"},
                {"Jpump25","SPPump25"},
                {"Jpump26","SPPump26"},
                {"Jpump27","SPPump27"}
            };
            var flag_mapping_dict = new Dictionary<string, int>(){
                { "SPPump21",GlobalHelper.Flag21},
                { "SPPump22",GlobalHelper.Flag22},
                { "SPPump23",GlobalHelper.Flag23},
                { "SPPump24",GlobalHelper.Flag24},
                { "SPPump25",GlobalHelper.Flag25},
                { "SPPump26",GlobalHelper.Flag26},
                { "SPPump27",GlobalHelper.Flag27}
            };
            var pumps = new IStation.Service.Station().Get().Station2;
            #endregion

            var list = new List<Tuple<string, double, double, List<Station2ScadaSchedule>>>();
            var minQ = 20000;
            var maxQ = 140000;
            var spaceQ = 5000;
            for (int currentMinQ = minQ; currentMinQ <= maxQ; currentMinQ += spaceQ)
            {
                var currentMaxQ = currentMinQ + spaceQ;
                var station_scada_schedule_list = all_station_scada_schedule_list
                      .Where(x => x.TotalFlow >= currentMinQ && x.TotalFlow <= currentMaxQ)
                      .ToList();
                if (station_scada_schedule_list == null || !station_scada_schedule_list.Any())
                    continue;

                var station_scada_schedule_group = station_scada_schedule_list.GroupBy(x => x.RunFlags);
                foreach (var item in station_scada_schedule_group)
                {
                    var run_flags = item.Key;
                    list.Add(new(run_flags, currentMinQ, currentMaxQ, item.ToList()));
                }
            }

            var scada_run_flags_head_avg_diff_dict_list = new List<Tuple<string,  double, double, Dictionary<int, double>, Dictionary<int, double>>>();
            foreach (var item in list)
            {
                var run_flags = item.Item1;
                var min_flow = item.Item2;
                var max_flow = item.Item3;
                var station_scada_schedule_list = item.Item4;
                var flag_head_avg_diff_dict = GetScadaFlagHeadAvgDiffDict(pumps, station_scada_schedule_list);
                var model_head_avg_diff_dict = GetModelFlagHeadAvgDiffDict(pumps, flag_mapping_dict, station_scada_schedule_list);
                scada_run_flags_head_avg_diff_dict_list.Add(new(run_flags, min_flow, max_flow, flag_head_avg_diff_dict, model_head_avg_diff_dict));
            }

            return scada_run_flags_head_avg_diff_dict_list;
        }

        private static Dictionary<string, string> _pump_pressure_id_mapping_dict2 = new()
            {
                {"Jpump21","SPPump21"},
                {"Jpump22","SPPump22"},
                {"Jpump23","SPPump23"},
                {"Jpump24","SPPump24"},
                {"Jpump25","SPPump25"},
                {"Jpump26","SPPump26"},
                {"Jpump27","SPPump27"}
            };
        public static Dictionary<int, double> GetModelFlagHeadAvgDiffDict
            (List<Model.Pump> pumps,
            Dictionary<string, int> flag_mapping_dict,
            List<Station2ScadaSchedule> station_scada_schedule_list)
        {
            if (station_scada_schedule_list == null || !station_scada_schedule_list.Any())
                return default;

            var err = EpanetMethods.ENopen(_model_file, "", "");
            if (err != ErrorCode.Ok)
                return default;

            err = EpanetMethods.ENopenH();
            if (err != ErrorCode.Ok)
                return default;

            var multi_tag_head_diff_list = new List<Tuple<string, double>>();
            var model_id_build = new StringBuilder(31);
            foreach (var station_scada_schedule in station_scada_schedule_list)
            {
                var pattern_init = true;
                var pattern_dict = station_scada_schedule.ToModelPatternDict();
                var scada_dict = station_scada_schedule.ToModelScadaDict();
                var pump_dict = station_scada_schedule.ToModelPumpDict();
                foreach (var pattern in pattern_dict)
                {
                    var pattern_id = pattern.Key;
                    var pattern_factor_array = pattern.Value;
                    var pattern_factor_array_count = pattern_factor_array.Length == 0 ? 1 : pattern_factor_array.Length;
                    err = EpanetMethods.ENgetpatternindex(pattern_id, out int pattern_index);
                    if (err != ErrorCode.Ok)
                    {
                        pattern_init = false;
                        continue;
                    }
                    err = EpanetMethods.ENsetpattern(pattern_index, pattern_factor_array, pattern_factor_array_count);
                    if (err != ErrorCode.Ok)
                    {
                        pattern_init = false;
                        continue;
                    }
                }
                if (!pattern_init)
                    continue;

                EpanetMethods.ENinitH(0);
                EpanetMethods.ENrunH(out _);
                EpanetMethods.ENgetcount(CountType.Node, out int node_count);

                for (int node_index = 1; node_index <= node_count; node_index++)
                {
                    if (EpanetMethods.ENgetnodeid(node_index, model_id_build) != ErrorCode.Ok)
                        continue;
                    var model_id = model_id_build.ToString();
                    if (_pump_pressure_id_mapping_dict2.ContainsKey(model_id))
                    {
                        var scada_id = _pump_pressure_id_mapping_dict2[model_id];
                        if (!(pump_dict[scada_id] > 0))
                        {
                            continue;
                        }
                        EpanetMethods.ENgetnodevalue(node_index, NodeValue.Head, out float model_head);
                        var scada_head = scada_dict[scada_id];
                        var head_diff = model_head - scada_head;
                        multi_tag_head_diff_list.Add(new(scada_id, head_diff));
                    }
                }
            }
            EpanetMethods.ENcloseH();
            EpanetMethods.ENclose();


            var tag_head_diff_list_group = multi_tag_head_diff_list.GroupBy(x => x.Item1).OrderBy(x => x.Key);
            var flag_head_avg_diff_dict = new Dictionary<int, double>();
            foreach (var item in tag_head_diff_list_group)
            {
                var flag = flag_mapping_dict[item.Key];
                var head_diff_avg = item.Average(x => x.Item2);
                flag_head_avg_diff_dict.Add(flag, head_diff_avg);
            }

            return flag_head_avg_diff_dict;
        }

        public static Dictionary<int, double> GetScadaFlagHeadAvgDiffDict(List<Model.Pump> pumps, List<Station2ScadaSchedule> station_scada_schedule_list)
        {
            if (station_scada_schedule_list == null || !station_scada_schedule_list.Any())
                return default;

            var multi_flag_head_diff_list = new List<Tuple<int, double>>();
            foreach (var station_scada_schedule in station_scada_schedule_list)
            {
                var time = station_scada_schedule.Time;
                var flag_inlet_water_level_dict = station_scada_schedule.ToFlagInletWaterLevelDict();
                var flag_rpm_dict = station_scada_schedule.ToFlagRpmDict();
                var flag_head_dict = station_scada_schedule.ToFlagHeadDict();
                var flag_flow_dict = station_scada_schedule.ToFlagFlowDict();

                foreach (var item in flag_rpm_dict)
                {
                    var flag = item.Key;
                    var pump = pumps.Find(x => x.Flag == flag);
                    if (pump == null)
                        continue;

                    var rpm = item.Value * pump.Nr;
                    if (rpm < 1)
                        continue;

                    var curve_qh = Curve.PumpCalculateHelper.CalculateSimilarQH(pump.CurveQH, pump.Nr, rpm);

                    var inlet_water_level = flag_inlet_water_level_dict[flag];
                    var flow = flag_flow_dict[pump.Flag];
                    var head = flag_head_dict[flag];

                    var curve_head = curve_qh.GetFitPointY(flow);
                    var head_diff = curve_head - (head - inlet_water_level);
                    multi_flag_head_diff_list.Add(new(flag, head_diff));
                }
            }

            var flag_head_diff_list_group = multi_flag_head_diff_list.GroupBy(x => x.Item1);
            var flag_head_avg_diff_dict = new Dictionary<int, double>();
            foreach (var item in flag_head_diff_list_group)
            {
                var flag = item.Key;
                var head_diff_avg = item.Average(x => x.Item2);
                flag_head_avg_diff_dict.Add(flag, head_diff_avg);
            }

            return flag_head_avg_diff_dict;
        }

        #endregion


    }

}