using Quartz;

namespace IStation.Server
{
    /// <summary>
    /// 模型验证辅助类
    /// </summary>
    [DisallowConcurrentExecution]//此特性标识 必须等待这次任务执行完成后，才能执行下次任务
    public class HydraulicModelValidationHelperJob : IJob
    {
        private static readonly string _hydraulic_model_file = Path.Combine(
               Settings.ParasHelper.LocalFile.DataFolderDirectory,
               Settings.ParasHelper.LocalFile.HydraulicModelFile);

        private static readonly Dictionary<string, double> _pump_nr_dict = new() {
            { "Pump11",590},
            { "Pump12",590},
            { "Pump13",590},
            { "Pump14",590},
            //{ "Pump15",590},
            //{ "Pump16",590},
            { "Pump17",590},
            { "Pump18",590},

            { "Pump21",740},
            { "Pump22",495},
            { "Pump23",495},
            { "Pump24",495},
            { "Pump25",495},
            { "Pump26",495},
            { "Pump27",740}
        };

        private static readonly List<string> _MPa = new();
        private static readonly List<string> _kPa = new();

        /// <summary>
        /// 
        /// </summary>
        public Task Execute(IJobExecutionContext context)
        {
            return Task.Run(() =>
            {
                var verification_id = Yw.YitIdHelper.NextId();
                var current_time = DateTime.Now;
                try
                {
                    if (!File.Exists(_hydraulic_model_file))
                    {
                        Log.Info(verification_id, $"模型验证计划任务中,水力模型文件不存在,自动跳过当前数据!");
                        return;
                    }
                    var hydraulic_model_validation_config = new IStation.Service.HydraulicModelValidationConfig().Get();
                    if (hydraulic_model_validation_config == null)
                    {
                        Log.Info(verification_id, "模型验证计划任务中,水力模型验证文件不存在,自动跳过当前数据!");
                        return;
                    }
                    if (!Settings.ParasHelper.ZyDocking.Enable)
                    {
                        Log.Info(verification_id, "模型验证计划任务中,Scada对接接口未启用,自动跳过当前数据!");
                        return;
                    }

                    var hydraulic_model_scada_list = new List<Model.HydraulicModelScada>();

                    var url = Settings.ParasHelper.ZyDocking.ScadaHttpUrl;
                    var response_text = Yw.Untity.HttpRequestHelper.Get(url);
                    var zy_scada_output = Yw.JsonHelper.Json2Object<IStation.Dto.ScadaScheduleInput>(response_text);
                    if (zy_scada_output.data != null && zy_scada_output.data.Any())
                    {
                        var data_dict = zy_scada_output.data;
                        foreach (var scada_dict in data_dict)
                        {
                            var vals = scada_dict.Value.ElementAt(0).Value;
                            var time = scada_dict.Value.ElementAt(1).Value;
                            var key = scada_dict.Value.ElementAt(2).Value;
                            var hydraulic_model_scada = new Model.HydraulicModelScada();
                            hydraulic_model_scada.VerificationID = verification_id;
                            hydraulic_model_scada.Tag = key;
                            if (DateTime.TryParse(time, out DateTime t))
                                hydraulic_model_scada.Time = t;
                            if (double.TryParse(vals, out double v))
                                hydraulic_model_scada.Value = v;
                            hydraulic_model_scada_list.Add(hydraulic_model_scada);
                        }
                    }


                    if (!hydraulic_model_scada_list.Any())
                    {
                        Log.Info(verification_id, "模型验证计划任务中,接收Scada数据为空,自动跳过当前数据!");
                        return;
                    }
                    else
                    {
                        var json = Yw.JsonHelper.Object2Json(hydraulic_model_scada_list);
                        Log.Debug(verification_id, json);
                    }


                    var flow_id_mapping_dict = hydraulic_model_validation_config.FlowIdMappingDict;
                    var pressure_id_mapping_dict = hydraulic_model_validation_config.PressureIdMappingDict;
                    var pattern_id_mapping_dict = hydraulic_model_validation_config.PatternIdMappingDict;

                    var pressure_id_kPa_list= hydraulic_model_validation_config.PressureIdkPaList;

                    var pattern_list = new List<IStation.Hydraulic.Pattern>();
                    var time_value = new IStation.Hydraulic.TimeValue
                    {
                        Time = current_time,
                        Value = new Dictionary<string, double>()
                    };

                    foreach (var hydraulic_model_scada in hydraulic_model_scada_list)
                    {
                        var tag = hydraulic_model_scada.Tag;
                        var value = hydraulic_model_scada.Value;
                        foreach (var item in flow_id_mapping_dict)
                        {
                            if (item.Value != tag)
                                continue;
                            time_value.Value.Add(tag, value ?? 0);
                        }

                        foreach (var item in pressure_id_mapping_dict)
                        {
                            if (item.Value != tag)
                                continue;
                            var pressure_value = value ?? 0;
                            if (pressure_id_kPa_list.Contains(tag))
                            {
                                pressure_value /= 1000;
                            }
                            pressure_value = IStation.Curve.PumpCalculateHelper.Mpa2M(pressure_value);
                            time_value.Value.Add(tag, pressure_value);
                        }

                        foreach (var item in pattern_id_mapping_dict)
                        {
                            if (item.Value != tag)
                                continue;
                            var pattern_id = item.Key;
                            var factor = value;
                            if (_pump_nr_dict.ContainsKey(pattern_id))
                            {
                                factor /= _pump_nr_dict[pattern_id];
                                factor = factor < 0 ? 0 : factor;
                            }
                            var pattern = new IStation.Hydraulic.Pattern
                            {
                                Id = pattern_id,
                                FactorList = new List<float>()
                            };
                            if (factor.HasValue)
                                pattern.FactorList.Add((float)factor.Value);
                            pattern_list.Add(pattern);
                        }
                    }

                   // Log.Info(verification_id,  _hydraulic_model_file);//text
                    var hydraulic_model_record_list = IStation.Hydraulic.ModeVerifyHelper.Verify(verification_id, _hydraulic_model_file, flow_id_mapping_dict, pressure_id_mapping_dict, pattern_list, time_value);
                    if (hydraulic_model_record_list == null || !hydraulic_model_record_list.Any())
                    {
                        Log.Info(verification_id, "模型验证计划任务中,模型验证数据为空，自动跳过当前数据!");
                        return;
                    }

                    var hydraulic_model_validation = new Model.HydraulicModelValidation();
                    hydraulic_model_validation.ID = verification_id;
                    hydraulic_model_validation.Time = current_time;
                    //hydraulic_model_validation.Config = Yw.JsonHelper.Object2Json(hydraulic_model_validation_config);

                    var bol = new IStation.Service.HydraulicModelValidation().Insert(hydraulic_model_validation) > 0;
                    if (!bol)
                    {
                        Log.Info(verification_id, "模型验证计划任务中,水力模型验证,保存失败!");
                    }

                    bol = new IStation.Service.HydraulicModelScada().Inserts(hydraulic_model_scada_list);
                    if (!bol)
                    {
                        Log.Info(verification_id, "模型验证计划任务中,水力模型Scada,保存失败!");
                    }

                    bol = new IStation.Service.HydraulicModelRecord().Inserts(hydraulic_model_record_list);
                    if (!bol)
                    {
                        Log.Info(verification_id, "模型验证计划任务中,水力模型记录,保存失败!");
                    }

                    Log.Info(verification_id, $"模型验证计划任务中,水力模型验证,[{current_time:G}]验证成功!");
                }
                catch (Exception ex)
                {
                    Log.Error(verification_id, "模型验证计划任务中,出错", ex);
                    var e = new JobExecutionException(ex);
                    throw e;
                }
            });
        }


    }
}