using Yw.Untity;

namespace IStation.Test
{
    public class ScheduleModelValidHelper
    {
        private static readonly Service.Station _service_station = new();
        private static readonly Service.ScheduleRequest _service_schedule_request = new();
        private static readonly Service.Scada _service_scada = new();
        private static readonly Service.ScheduleConfig _service_schedule_config = new(); 
        private static readonly Service.ScheduleScada _service_schedule_scada = new();
        private static readonly Service.ScheduleRule _service_schedule_rule = new();
        private static readonly Service.ScheduleConclusion _service_schedule_conclusion = new();
        private static readonly Service.SchedulePump _service_schedule_pump = new();


        public static bool Schedule()
        {
            var water_level_tag_list_1 = new List<string>()
            {
                 "R1",
                 "R2",
                 "R3"
            };
            var water_level_tag_list_2 = new List<string>()
            {
                 "RPump21",
                 "RPump22",
                 "RPump23",
                 "RPump24",
                 "RPump25",
                 "RPump26",
                 "RPump27"
            };

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

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

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

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


            var pump_id_mapping_list1 = new Dictionary<string, int>()
            {
                {"Pump11",11},
                {"Pump12",12},
                {"Pump13",13},
                {"Pump14",14},
                {"Pump15",15},
                {"Pump16",16},
                {"Pump17",17},
                {"Pump18",18},
            };

            var pump_id_mapping_list2 = new Dictionary<string, int>()
            {
                {"Pump21",21},
                {"Pump22",22},
                {"Pump23",23},
                {"Pump24",24},
                {"Pump25",25},
                {"Pump26",26},
                {"Pump27",27},
            };


            var station_info = _service_station.Get();
            var schedule_config1 = _service_schedule_config.GetStation1();
            var schedule_config2 = _service_schedule_config.GetStation2();


            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;
            day_value_list = day_value_list.OrderBy(x => x.Month).ThenBy(x => x.Day).ToList();
            // day_value_list = day_value_list.Where(x => x.Month == 1 && x.Day == 13).OrderBy(x => x.Day).ToList();

            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>();

            var current_open_pump_flags1 = new List<int>();
            var current_open_pump_flags2 = new List<int>();

            var water_level_valid_value_list1 = new List<double>();
            var water_level_valid_value_list2 = new List<double>();

            var helper = new Algorithm.ScheduleHelper();


            //try
            //{
            foreach (var day_value in day_value_list)
            {
                var date = $"{day_value.Year}-{day_value.Month}-{day_value.Day}";
                Console.WriteLine($"调度分析，{date}");

                var schedule_request_list = new List<Model.ScheduleRequest>();
                var schedule_conclusion_list = new List<Model.ScheduleConclusion>();
                var schedule_pump_list = new List<Model.SchedulePump>();


                var time_value_list = day_value.TimeValueList;
                foreach (var time_value in time_value_list)
                {
                    pressure_1_list.Clear();
                    flow_1_list.Clear();
                    pressure_2_list.Clear();
                    flow_2_list.Clear();
                    current_open_pump_flags1.Clear();
                    current_open_pump_flags2.Clear();
                    water_level_valid_value_list1.Clear();
                    water_level_valid_value_list2.Clear();

                    var time = time_value.Time;
                    var value_dict = time_value.Value;
                    var request_id = Yw.YitIdHelper.NextId();


                    foreach (var zy_scada in value_dict)
                    {
                        var scada_id = zy_scada.Key;
                        var scada_value = zy_scada.Value;

                        if (pressure_id_mapping_list1.Contains(scada_id))
                        {
                            pressure_1_list.Add(scada_value);
                            continue;
                        }
                        else if (pressure_id_mapping_list2.Contains(scada_id))
                        {
                            pressure_2_list.Add(scada_value);
                            continue;
                        }
                        else if (flow_id_mapping_list1.Contains(scada_id))
                        {
                            flow_1_list.Add(scada_value);
                            continue;
                        }
                        else if (flow_id_mapping_list2.Contains(scada_id))
                        {
                            flow_2_list.Add(scada_value);
                            continue;
                        }
                        else if (water_level_tag_list_1.Contains(scada_id))
                        {
                            water_level_valid_value_list1.Add(scada_value);
                            continue;
                        }
                        else if (water_level_tag_list_2.Contains(scada_id))
                        {
                            water_level_valid_value_list2.Add(scada_value);
                            continue;
                        }
                        bool ct = false;
                        foreach (var pump in pump_id_mapping_list1)
                        {
                            if (pump.Key == scada_id && scada_value > 0)
                            {
                                current_open_pump_flags1.Add(pump.Value);
                                ct = true;
                            }
                        }
                        if (ct)
                            continue;
                        foreach (var pump in pump_id_mapping_list2)
                        {
                            if (pump.Key == scada_id && scada_value > 0)
                            {
                                current_open_pump_flags2.Add(pump.Value);
                            }
                        }
                    }


                    var water_level1 = water_level_valid_value_list1.Average(x => x);
                    var water_level2 = water_level_valid_value_list2.Average(x => x);

                    var target_flow1 = flow_1_list.Sum();
                    var target_flow2 = flow_2_list.Sum();

                    var pressure_1 = pressure_1_list.Max();
                    var pressure_2 = pressure_2_list.Max();


                    var target_head1 = pressure_1 - water_level1;
                    var target_head2 = pressure_2 - water_level2;


                    var dt_now = DateTime.Now;
                    helper.Initial(current_open_pump_flags1, schedule_config1);
                    var optimal_combine1 = helper.Calc(station_info.Station1, 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.Station2, station_info.S2FlagsPart1, station_info.S2FlagsPart2, target_flow2, target_head2);

                    if (optimal_combine1 == null && optimal_combine2 == null)
                        continue;

                    Model.ScheduleRequest schedule_request = new Model.ScheduleRequest();
                    schedule_request = new Model.ScheduleRequest();
                    schedule_request.ID = request_id;
                    schedule_request.TargetFlow1 = target_flow1;
                    schedule_request.TargetPressure1 = IStation.Curve.PumpCalculateHelper.M2Mpa(pressure_1);
                    schedule_request.TargetFlow2 = target_flow2;
                    schedule_request.TargetPressure2 = IStation.Curve.PumpCalculateHelper.M2Mpa(pressure_2);
                    schedule_request.WaterLevel1 = water_level1;
                    schedule_request.WaterLevel2 = water_level2;
                    schedule_request.ScheduleStatus1 = optimal_combine1 != null;
                    schedule_request.ScheduleStatus2 = optimal_combine2 != null;
                    schedule_request.TotalTimeSpent = (DateTime.Now - dt_now).TotalSeconds;
                    schedule_request.ReceptionTime = time;
                    schedule_request_list.Add(schedule_request);

                    Model.ScheduleConclusion schedule_conclusion1 = null;
                    Model.ScheduleConclusion schedule_conclusion2 = null;
                    List<Model.SchedulePump> schedule_pump_list1 = null;
                    List<Model.SchedulePump> schedule_pump_list2 = null;

                    if (optimal_combine1 != null)
                    {
                        schedule_conclusion1 = new Model.ScheduleConclusion();
                        schedule_conclusion1.ID = Yw.YitIdHelper.NextId();
                        schedule_conclusion1.RequestID = request_id;
                        schedule_conclusion1.Station = IStation.eDockingStation.Ch1s;
                        schedule_conclusion1.TotalFlow = optimal_combine1.Flow;
                        schedule_conclusion1.TotalHead = optimal_combine1.Head;
                        schedule_conclusion1.TotalPower = optimal_combine1.Power;
                        schedule_conclusion1.TotalEfficiency = optimal_combine1.Efficiency;
                        schedule_conclusion1.WP = optimal_combine1.WP;
                        schedule_conclusion1.UWP = optimal_combine1.UWP;
                        schedule_conclusion1.Flags = IntListHelper.ToString(optimal_combine1.Flags);
                        schedule_conclusion1.MeritRatio = optimal_combine1.MeritRatio;
                        schedule_conclusion_list.Add(schedule_conclusion1);

                        schedule_pump_list1 = new List<Model.SchedulePump>();
                        foreach (var combine in optimal_combine1.Combines)
                        {
                            foreach (var fre_pump in combine.FrePumps)
                            {
                                var flag = fre_pump.Flag;
                                var schedule_pump = new Model.SchedulePump();
                                schedule_pump.RequestID = request_id;
                                schedule_pump.Station = IStation.eDockingStation.Ch1s;
                                schedule_pump.Flag = flag;
                                schedule_pump.Flow = fre_pump.Flow;
                                schedule_pump.Head = fre_pump.Head;
                                schedule_pump.Power = fre_pump.Power;
                                schedule_pump.Efficiency = fre_pump.Efficiency;
                                schedule_pump.Frequency = fre_pump.Frequency;
                                schedule_pump.Speed = fre_pump.Speed;
                                schedule_pump_list1.Add(schedule_pump);
                            }
                        }
                        schedule_pump_list.AddRange(schedule_pump_list1);
                    }


                    if (optimal_combine2 != null)
                    {
                        schedule_conclusion2 = new Model.ScheduleConclusion();
                        schedule_conclusion2.ID = Yw.YitIdHelper.NextId();
                        schedule_conclusion2.RequestID = request_id;
                        schedule_conclusion2.Station = IStation.eDockingStation.Ch2s;
                        schedule_conclusion2.TotalFlow = optimal_combine2.Flow;
                        schedule_conclusion2.TotalHead = optimal_combine2.Head;
                        schedule_conclusion2.TotalPower = optimal_combine2.Power;
                        schedule_conclusion2.TotalEfficiency = optimal_combine2.Efficiency;
                        schedule_conclusion2.WP = optimal_combine2.WP;
                        schedule_conclusion2.UWP = optimal_combine2.UWP;
                        schedule_conclusion2.Flags = IntListHelper.ToString(optimal_combine2.Flags);
                        schedule_conclusion2.MeritRatio = optimal_combine2.MeritRatio;
                        schedule_conclusion_list.Add(schedule_conclusion2);

                        schedule_pump_list2 = new List<Model.SchedulePump>();
                        foreach (var combine in optimal_combine2.Combines)
                        {
                            foreach (var fre_pump in combine.FrePumps)
                            {
                                var flag = fre_pump.Flag;
                                var schedule_pump = new Model.SchedulePump();
                                schedule_pump.RequestID = request_id;
                                schedule_pump.Station = IStation.eDockingStation.Ch2s;
                                schedule_pump.Flag = flag;
                                schedule_pump.Flow = fre_pump.Flow;
                                schedule_pump.Head = fre_pump.Head;
                                schedule_pump.Power = fre_pump.Power;
                                schedule_pump.Efficiency = fre_pump.Efficiency;
                                schedule_pump.Frequency = fre_pump.Frequency;
                                schedule_pump.Speed = fre_pump.Speed;
                                schedule_pump_list2.Add(schedule_pump);
                            }
                        }
                        schedule_pump_list.AddRange(schedule_pump_list2);
                    }

                }

                var bol = false;
                if (schedule_request_list != null && schedule_request_list.Any())
                {
                    bol = _service_schedule_request.Inserts(schedule_request_list);
                    if (!bol)
                    {
                        var msg = $"{date}:schedule_request_list 插入异常";
                        Console.WriteLine(msg);
                        Yw.LogHelper.Info(msg);
                    }
                }

                if (schedule_conclusion_list != null && schedule_conclusion_list.Any())
                {
                    bol = _service_schedule_conclusion.Inserts(schedule_conclusion_list);
                    if (!bol)
                    {
                        var msg = $"{date}:schedule_conclusion_list 插入异常";
                        Console.WriteLine(msg);
                        Yw.LogHelper.Info(msg);
                    }
                }

                if (schedule_pump_list != null && schedule_pump_list.Any())
                {
                    bol = _service_schedule_pump.Inserts(schedule_pump_list);
                    if (!bol)
                    {
                        var msg = $"{date}:schedule_pump_list 插入异常";
                        Console.WriteLine(msg);
                        Yw.LogHelper.Info(msg);
                    }

                };
            }
            //}
            //catch (Exception ex)
            //{
            //    var msg = $"异常!{ex.Message}";
            //    Console.WriteLine(msg);
            //    Yw.LogHelper.Error("异常!", ex);
            //}
            return true;
        }
 



        ///// <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="day_value_list">每日分析数据</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<DayValue> day_value_list)
        //{
        //    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 = "流量标签字典为空!"; 
        //        return default;
        //    }
        //    if (pressure_id_mapping_dict == null || !pressure_id_mapping_dict.Any())
        //    {
        //        log_msg = "压力标签字典为空!"; 
        //        return default;
        //    }
        //    if (day_value_list == null || !day_value_list.Any())
        //    {
        //        log_msg = "日验证数据为空!"; 
        //        return default;
        //    }

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

        //    log_msg = "初始化成功"; 

        //    log_title = "验证";
        //    var model_time_step = 0;
        //    var model_id_build = new StringBuilder(31);
        //    foreach (var day_value in day_value_list)
        //    {
        //        var pattern_list = day_value.PatternList;
        //        var time_value_list = day_value.TimeValueList;
        //        if (pattern_list == null || time_value_list == null)
        //        {
        //            continue;
        //        }
        //        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();
        //                continue;
        //            }
        //            err = EpanetMethods.ENsetpattern(pattern_index, pattern_factor_array, pattern_factor_array_count);
        //            if (err != ErrorCode.Ok)
        //            {
        //                pattern_init = false;
        //                log_msg = err.GetMsg();
        //                continue;
        //            }
        //        }

        //        if (!pattern_init)
        //        {
        //            log_msg = $"{day_value.Year}_{day_value.Month}_{day_value.Day}:模式初始化失败!"; 
        //            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;
        //                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_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_record_list.Add(record);
        //                    }
        //                }
        //            }

        //            EpanetMethods.ENnextH(out model_time_step);

        //        } while (model_time_step > 0);
        //    }
        //    EpanetMethods.ENcloseH();
        //    return hydraulic_record_list;
        //}

    }
}