using IStation.Epanet.Enums;
using IStation.Epanet;
using IStation.Hydraulic;
using System.Text;
using Yw.Untity;
using System.Collections.Generic;

namespace IStation.Test
{
    public class ScheduleModelValidHelper
    {
        public bool Analysis()
        {  
            var pressure_id_mapping_dict = new Dictionary<string, string>()
            {
                {"Jjd1","1输水总压力"},
                {"Jjd2","1输水总压力"},
                {"Jjd3","1输水总压力"},
                {"Jpump11","1输水11#扬程"},
                {"Jpump12","1输水12#扬程"},
                {"Jpump13","1输水13#扬程"},
                {"Jpump14","1输水14#扬程"},
                {"Jpump15","1输水15#扬程"},
                {"Jpump16","1输水16#扬程"},
                {"Jpump17","1输水17#扬程"},
                {"Jpump18","1输水18#扬程"},

                {"Jdn2400","2输水总压力"},
                {"Jdn2700","2输水总压力"},
                {"Jpump21","2输水21#扬程"},
                {"Jpump22","2输水22#扬程"},
                {"Jpump23","2输水23#扬程"},
                {"Jpump24","2输水24#扬程"},
                {"Jpump25","2输水25#扬程"},
                {"Jpump26","2输水26#扬程"},
                {"Jpump27","2输水27#扬程"}
            };


            var flow_id_mapping_dict = new Dictionary<string, string>()
            {
                {"Pjd1","1输水总流量"},
                {"Pjd2","1输水总流量"},
                {"Pjd3","1输水总流量"},
                {"Pdn2400","2输水总流量"},
                {"Pdn2700","2输水总流量"},
                {"Ppump21","2输水21#流量"},
                {"Ppump22","2输水22#流量"},
                {"Ppump23","2输水23#流量"},
                {"Ppump24","2输水24#流量"},
                {"Ppump25","2输水25#流量"},
                {"Ppump26","2输水26#流量"},
                {"Ppump27","2输水27#流量"}
            };


            var pattern_id_mapping_dict = new Dictionary<string, string>()
            {
                {"Pump11","1输水11#频率"},
                {"Pump12","1输水12#频率"},
                {"Pump13","1输水13#频率"},
                {"Pump14","1输水14#频率"},
                {"Pump15","1输水15#频率"},
                {"Pump16","1输水16#频率"},
                {"Pump17","1输水17#频率"},
                {"Pump18","1输水18#频率"},
                {"R3", "R3"},
                {"R2", "R2"},
                {"R1", "R1"},
                {"SFJD1", "SFJD1"},
                {"SFJD2", "SFJD2"},
                {"SFJD3", "SFJD3"},
                {"RPump21", "RPump21"},
                {"SFPump21", "SFPump21"},
                {"Pump21", "2输水21#频率"},
                {"RPump22", "RPump22"},
                {"SFPump22", "SFPump22"},
                {"Pump22", "2输水22#频率"},
                {"RPump23", "RPump23"},
                {"SFPump23", "SFPump23"},
                {"Pump23", "2输水23#频率"},
                {"RPump24", "RPump24"},
                {"SFPump24", "SFPump24"},
                {"Pump24", "2输水24#频率"},
                {"RPump25", "RPump25"},
                {"SFPump25", "SFPump25"},
                {"Pump25", "2输水25#频率"},
                {"RPump26", "RPump26"},
                {"SFPump26", "SFPump26"},
                {"Pump26", "2输水26#频率"},
                {"RPump27", "RPump27"},
                {"SFPump27", "SFPump27"},
                {"Pump27", "2输水27#频率"},
                {"SFDN2400", "SFDN2400"},
                {"SFDN2700", "SFDN2700"}
            };


            var pressure_id_mapping_dict1 =new List<string>()
            {
                 "SPJD1",
                 "SPJD2",
                 "SPJD3"
            };


            var pressure_id_mapping_dict2 = new List<string>()
            {
                 "SPDN2400",
                 "SPDN2700"
            };

            var flow_id_mapping_dict1 = new List<string>()
            {
                 "SFJD1",
                 "SFJD2",
                 "SFJD3"
            };

            var flow_id_mapping_dict2 = new List<string>()
            {
                 "SFDN2400",
                 "SFDN2700" 
            };


            var verify_id = Yw.YitIdHelper.NextId();
            var file_path = $"{AppDomain.CurrentDomain.BaseDirectory}Data\\HydraulicModel.inp";

            var day_value_list = IStation.Test.DayValueHelper.GetDayValues();
            if (day_value_list == null || !day_value_list.Any())
                return false;
            foreach (var day_value in day_value_list)
            {
       
                var patternList = new List<IStation.Hydraulic.Pattern>();
                foreach (var pattern_item in pattern_id_mapping_dict)
                {
                    var pattern = new IStation.Hydraulic.Pattern
                    {
                        Id = pattern_item.Key,
                        FactorList = new List<float>()
                    };
                    patternList.Add(pattern);
                }

                var timeValueList = day_value.TimeValueList.OrderBy(x => x.Time).ToList();
                foreach (var timeValue in timeValueList)
                {
                    var time = timeValue.Time;
                    var value_dict = timeValue.Value;

                    var pressure_1_list = new List<double>();
                    var flow_1_list = new List<double>();

                    var pressure_2_list = new List<double>();
                    var flow_2_list = new List<double>();

                    foreach (var item in value_dict)
                    {
                        var scada_id = item.Key;
                        var scada_value = item.Value;
                        var pattern = patternList.Find(x => x.Id == scada_id);
                        if (pattern != null)
                        {
                            if (pattern.Id != scada_id)
                                continue;
                            pattern.FactorList.Add((float)scada_value);
                        }

                        if (pressure_id_mapping_dict1.Contains(scada_id))
                        {
                            pressure_1_list.Add(scada_value);
                        }
                        else if (pressure_id_mapping_dict2.Contains(scada_id))
                        {
                            pressure_2_list.Add(scada_value);
                        }
                        else if (flow_id_mapping_dict1.Contains(scada_id))
                        {
                            flow_1_list.Add(scada_value);
                        }
                        else if (flow_id_mapping_dict2.Contains(scada_id))
                        {
                            flow_2_list.Add(scada_value);
                        } 
                    }

                    var pressure_1 = pressure_1_list.Max();
                    var flow_1 = flow_1_list.Sum();

                    var pressure_2 = pressure_2_list.Max(); 
                    var flow_2= flow_2_list.Sum();

                    var helper = new Algorithm.ScheduleHelper();
                    helper.Initial(current_open_pump_flags1, schedule_config1);
                    var optimal_combine1 = helper.Calc(station_info.S1, station_info.S1FlagsPart1, station_info.S1FlagsPart2, target_flow1, target_head1);

                    helper.Initial(current_open_pump_flags2, schedule_config2);
                    var optimal_combine2 = helper.Calc(station_info.S2, station_info.S2FlagsPart1, station_info.S2FlagsPart2, target_flow2, target_head2);
                     
                }


                day_value.PatternList = patternList;
            }

            var hydraulic_model_validation = new IStation.Model.HydraulicModelValidation();
            hydraulic_model_validation.ID = verify_id;
            hydraulic_model_validation.Time = DateTime.Now;
            hydraulic_model_validation.Config = "调度验证";

            var bol = new IStation.Service.HydraulicModelValidation().Insert(hydraulic_model_validation) > 0;
            if (!bol)
            {
                return false;
            }

            var hydraulic_model_record_list = IStation.Hydraulic.ModeVerifyHelper.Verify(verify_id, file_path, flow_id_mapping_dict, pressure_id_mapping_dict, day_value_list);
            bol = new IStation.Service.HydraulicModelRecord().BulkInserts(hydraulic_model_record_list);
            return bol;
        }

        /// <summary>
        /// 实时验证
        /// </summary>
        /// <param name="verify_id">验证标识</param>
        /// <param name="file_path">文件</param>
        /// <param name="flow_id_mapping_dict">流量Scada标识字典</param>
        /// <param name="pressure_id_mapping_dict">压力Scada标识字典</param>
        /// <param name="pattern_list"></param>
        /// <param name="time_value">验证数据</param>
        /// <returns></returns>
        public static List<Model.HydraulicModelRecord> Verify(long verify_id, string file_path, Dictionary<string, string> flow_id_mapping_dict, Dictionary<string, string> pressure_id_mapping_dict, List<Pattern> pattern_list, TimeValue time_value)
        {
            var log_title = "初始化";
            var log_msg = string.Empty;
            var hydraulic_record_list = new List<Model.HydraulicModelRecord>();
            if (flow_id_mapping_dict == null || !flow_id_mapping_dict.Any())
            {
                log_msg = "流量标签字典为空!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }
            if (pressure_id_mapping_dict == null || !pressure_id_mapping_dict.Any())
            {
                log_msg = "压力标签字典为空!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }
            if (pattern_list == null || !pattern_list.Any())
            {
                log_msg = "模式数据为空!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }
            if (time_value == null)
            {
                log_msg = "验证数据为空!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }

            var err = EpanetMethods.ENopen(file_path, "", "");
            if (err != 0)
            {
                log_msg = err.GetMsg();
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }
            err = EpanetMethods.ENopenH();
            if (err != 0)
            {
                log_msg = err.GetMsg();
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }


            log_title = "验证";
            var model_id_build = new StringBuilder(31);
            var pattern_init = true;
            foreach (var pattern in pattern_list)
            {
                var pattern_id = 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(pattern_id, out int pattern_index);

                if (err != ErrorCode.Ok)
                {
                    pattern_init = false;
                    log_msg = err.GetMsg();
                    Log.Info(verify_id, log_title, 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();
                    Log.Info(verify_id, log_title, log_msg);
                    continue;
                }
            }

            if (!pattern_init)
            {
                log_msg = $"{time_value.Time:G}:模式初始化失败!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }

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

            var time = time_value.Time;
            var scada_value_dcit = time_value.Value;
            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);
                    model_value = Math.Abs(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;
                    record.DifferenceValue = record.ScadaValue - record.ModeValue;
                    hydraulic_record_list.Add(record);
                }

                EpanetMethods.ENgetlinktype(link_index, out LinkType linkType);
                if (linkType == LinkType.Pump)
                {
                    EpanetMethods.ENgetlinkvalue(link_index, LinkValue.InitStatus, out float on_off);
                }
            }

            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;
                    record.DifferenceValue = record.ScadaValue - record.ModeValue;
                    hydraulic_record_list.Add(record);
                }
            }

            EpanetMethods.ENcloseH();
            return hydraulic_record_list;
        }

    }
}