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

namespace IStation.Test
{
    public class ScadaModelValidHelper
    {
        public static bool Analysis()
        {
            var file_path = $"{AppDomain.CurrentDomain.BaseDirectory}Data\\HydraulicModel.inp";
            if (!File.Exists(file_path))
                return false;

            var day_value_list = IStation.Test.DayValueHelper.GetDayValues();
            if (day_value_list == null || !day_value_list.Any())
                return false;

            var service_hydraulic_model_validation = new IStation.Service.HydraulicModelValidation();
            var service_hydraulic_model_scada = new IStation.Service.HydraulicModelScada();
            var service_hydraulic_model_record = new IStation.Service.HydraulicModelRecord();

            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" },

                {"Jdn2400","SPDN2400"},
                {"Jdn2700","SPDN2700"},
                {"Jpump21","SPPump21"},
                {"Jpump22","SPPump22"},
                {"Jpump23","SPPump23"},
                {"Jpump24","SPPump24"},
                {"Jpump25","SPPump25"},
                {"Jpump26","SPPump26"},
                {"Jpump27","SPPump27"}
            };
            var flow_id_mapping_dict = new Dictionary<string, string>()
            {
                {"Pjd1","SFJD1"},
                {"Pjd2","SFJD2"},
                {"Pjd3","SFJD3"},

                {"Pdn2400","SFDN2400"},
                {"Pdn2700","SFDN2700"},
                {"Ppump21","SFPump21"},
                {"Ppump22","SFPump22"},
                {"Ppump23","SFPump23"},
                {"Ppump24","SFPump24"},
                {"Ppump25","SFPump25"},
                {"Ppump26","SFPump26"},
                {"Ppump27","SFPump27"}
            };
            var pattern_id_mapping_dict = new Dictionary<string, string>()
            {
                {"R3", "R3"},
                {"R2", "R2"},
                {"R1", "R1"},
                {"Pump11", "Pump11"},
                {"Pump12", "Pump12"},
                {"Pump13", "Pump13"},
                {"Pump14", "Pump14"},
                {"Pump15", "Pump15"},
                {"Pump16", "Pump16"},
                {"Pump17", "Pump17"},
                {"Pump18", "Pump18"},
                {"SFJD1", "SFJD1"},
                {"SFJD2", "SFJD2"},
                {"SFJD3", "SFJD3"},

                {"RPump21", "RPump21"},
                {"RPump22", "RPump22"},
                {"RPump23", "RPump23"},
                {"RPump24", "RPump24"},
                {"RPump25", "RPump25"},
                {"RPump26", "RPump26"},
                {"RPump27", "RPump27"},
                {"Pump21", "Pump21"},
                {"Pump22", "Pump22"},
                {"Pump23", "Pump23"},
                {"Pump24", "Pump24"},
                {"Pump25", "Pump25"},
                {"Pump26", "Pump26"},
                {"Pump27", "Pump27"},
                {"SFPump21", "SFPump21"},
                {"SFPump22", "SFPump22"},
                {"SFPump23", "SFPump23"},
                {"SFPump24", "SFPump24"},
                {"SFPump25", "SFPump25"},
                {"SFPump26", "SFPump26"},
                {"SFPump27", "SFPump27"},
                {"SFDN2400", "SFDN2400"},
                {"SFDN2700", "SFDN2700"},
            };

            var hydraulic_model_validation_config = new IStation.Model.HydraulicModelValidationConfig();
            hydraulic_model_validation_config.FlowIdMappingDict = flow_id_mapping_dict;
            hydraulic_model_validation_config.PressureIdMappingDict = pressure_id_mapping_dict;
            hydraulic_model_validation_config.PatternIdMappingDict = pattern_id_mapping_dict;
            var hydraulic_model_validation_config_json = Yw.JsonHelper.Object2Json(hydraulic_model_validation_config);


            var pattern_list = new List<IStation.Hydraulic.Pattern>();
            foreach (var pattern_id_mapping in pattern_id_mapping_dict)
            {
                var pattern = new IStation.Hydraulic.Pattern
                {
                    Id = pattern_id_mapping.Key,
                    FactorList = new List<float>()
                };
                pattern_list.Add(pattern);
            }

            var log_msg = string.Empty;
            var err = EpanetMethods.ENopen(file_path, "", "");
            if (err != 0)
            {
                log_msg = err.GetMsg();
                Console.WriteLine(log_msg);
                Yw.LogHelper.Info(log_msg);
                return default;
            }

            err = EpanetMethods.ENopenH();
            if (err != 0)
            {
                log_msg = err.GetMsg();
                Console.WriteLine(log_msg);
                Yw.LogHelper.Info(log_msg);
                return default;
            }

            var model_time_step = 0;
            var model_id_build = new StringBuilder(31);
            foreach (var day_value in day_value_list)
            {
                var date = $"{day_value.Year}-{day_value.Month}-{day_value.Day}";
                Console.WriteLine($"模型分析，{date}");

                var hydraulic_model_validation_list = new List<IStation.Model.HydraulicModelValidation>();
                var hydraulic_model_record_list = new List<Model.HydraulicModelRecord>();
                var hydraulic_model_scada_list = new List<Model.HydraulicModelScada>();

                pattern_list.ForEach(x => x.FactorList.Clear());
                var time_value_list = day_value.TimeValueList.OrderBy(x => x.Time).ToList();
                foreach (var time_value in time_value_list)
                {
                    var time = time_value.Time;
                    var value_dict = time_value.Value;
                    foreach (var value_item in value_dict)
                    {
                        var scada_id = value_item.Key;
                        var scada_value = value_item.Value;
                        var pattern = pattern_list.Find(x => x.Id == scada_id);
                        if (pattern != null)
                        {
                            pattern.FactorList.Add((float)scada_value);
                        }
                    }
                }

                var pattern_init = true;
                foreach (var pattern in pattern_list)
                {
                    var patternId = pattern.Id;
                    var pattern_factor_array = pattern.FactorList.ToArray();
                    var pattern_factor_array_count = pattern_factor_array.Length == 0 ? 1 : pattern_factor_array.Length;
                    err = EpanetMethods.ENgetpatternindex(patternId, out int pattern_index);
                    if (err != ErrorCode.Ok)
                    {
                        pattern_init = false;
                        log_msg = err.GetMsg();
                        Console.WriteLine(log_msg);
                        Yw.LogHelper.Info(log_msg);
                        continue;
                    }
                    err = EpanetMethods.ENsetpattern(pattern_index, pattern_factor_array, pattern_factor_array_count);
                    if (err != ErrorCode.Ok)
                    {
                        pattern_init = false;
                        log_msg = err.GetMsg();
                        Console.WriteLine(log_msg);
                        Yw.LogHelper.Info(log_msg);
                        continue;
                    }
                }

                if (!pattern_init)
                {
                    log_msg = $"{day_value.Year}_{day_value.Month}_{day_value.Day}:模式初始化失败!";
                    Console.WriteLine(log_msg);
                    Yw.LogHelper.Info(log_msg);
                    continue;
                }


                EpanetMethods.ENinitH(0);
                do
                {
                    EpanetMethods.ENrunH(out int current_ts);
                    EpanetMethods.ENgetcount(CountType.Link, out int link_count);
                    EpanetMethods.ENgetcount(CountType.Node, out int node_count);

                    var current_time = TimeSpan.FromSeconds(current_ts);
                    var time_value = time_value_list.Find(x => x.Time.TimeOfDay == current_time);
                    if (time_value != null)
                    {
                        var time = time_value.Time;
                        var scada_value_dcit = time_value.Value;

                        var verify_id = Yw.YitIdHelper.NextId();
                        var hydraulic_model_validation = new IStation.Model.HydraulicModelValidation();
                        hydraulic_model_validation.ID = verify_id;
                        hydraulic_model_validation.Time = time;
                        hydraulic_model_validation.Config = hydraulic_model_validation_config_json;
                        hydraulic_model_validation_list.Add(hydraulic_model_validation);

                        foreach (var valud_item in scada_value_dcit)
                        {
                            var hydraulic_model_scada = new Model.HydraulicModelScada();
                            hydraulic_model_scada.VerificationID = verify_id;
                            hydraulic_model_scada.Time = time;
                            hydraulic_model_scada.Tag = valud_item.Key;
                            hydraulic_model_scada.Value = valud_item.Value;
                            hydraulic_model_scada_list.Add(hydraulic_model_scada);
                        }

                        for (int link_index = 1; link_index <= link_count; link_index++)
                        {
                            if (EpanetMethods.ENgetlinkid(link_index, model_id_build) != ErrorCode.Ok)
                                continue;
                            var model_id = model_id_build.ToString();
                            if (flow_id_mapping_dict.ContainsKey(model_id))
                            {
                                var scada_id = flow_id_mapping_dict[model_id];
                                var scada_value = scada_value_dcit[scada_id];
                                EpanetMethods.ENgetlinkvalue(link_index, LinkValue.Flow, out float model_value);

                                var record = new IStation.Model.HydraulicModelRecord();
                                record.VerificationID = verify_id;
                                record.Time = time;
                                record.ModelId = model_id;
                                record.ScadaId = scada_id;
                                record.ValueType = IStation.eValueType.Flow;
                                record.ModeValue = (double)model_value;
                                record.ScadaValue = scada_value;
                                if (record.ModeValue.HasValue)
                                    record.ModeValue = Math.Abs(record.ModeValue.Value);
                                record.DifferenceValue = record.ScadaValue - record.ModeValue;
                                hydraulic_model_record_list.Add(record);
                            }

                        }

                        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 (pressure_id_mapping_dict.ContainsKey(model_id))
                            {
                                var scada_id = pressure_id_mapping_dict[model_id];
                                var scada_value = scada_value_dcit[scada_id];

                                EpanetMethods.ENgetnodevalue(node_index, NodeValue.Head, out float model_value);

                                var record = new IStation.Model.HydraulicModelRecord();
                                record.VerificationID = verify_id;
                                record.Time = time;
                                record.ModelId = model_id;
                                record.ScadaId = scada_id;
                                record.ValueType = IStation.eValueType.Head;
                                record.ModeValue = (double)model_value;
                                record.ScadaValue = scada_value;
                                if (record.ModeValue.HasValue)
                                    record.ModeValue = Math.Abs(record.ModeValue.Value);
                                record.DifferenceValue = record.ScadaValue - record.ModeValue;
                                hydraulic_model_record_list.Add(record);
                            }
                        }
                    }

                    EpanetMethods.ENnextH(out model_time_step);

                } while (model_time_step > 0);


                var bol = service_hydraulic_model_validation.Inserts(hydraulic_model_validation_list);
                if (!bol)
                {
                    var msg = $"{date}:hydraulic_model_validation_list 插入异常";
                    Console.WriteLine(msg);
                    Yw.LogHelper.Info(msg);
                }

                bol = service_hydraulic_model_scada.Inserts(hydraulic_model_scada_list);
                if (!bol)
                {
                    var msg = $"{date}:hydraulic_model_scada_list 插入异常";
                    Console.WriteLine(msg);
                    Yw.LogHelper.Info(msg);
                }

                bol = service_hydraulic_model_record.Inserts(hydraulic_model_record_list);
                if (!bol)
                {
                    var msg = $"{date}:hydraulic_model_record_list 插入异常";
                    Console.WriteLine(msg);
                    Yw.LogHelper.Info(msg);
                }
            }

            EpanetMethods.ENcloseH();

            return true;

        }


    }



        
}