namespace IStation
{
    /// <summary>
    /// 模型验证辅助类
    /// </summary> 
    public class HydraulicModelValidationHelperJob 
    {
        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 static void Execute()
        {
            var verification_id = 1;
            var current_time = DateTime.Now;

            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 fileName = "D:\\ScadaDebug.json";
            var json = File.ReadAllText(fileName);
            var hydraulic_model_scada_list = Yw.JsonHelper.Json2Object<List<IStation.Model.HydraulicModelScada>>(json);

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

            var pattern_dict = new Dictionary<string, double>();
            pattern_list = pattern_list.OrderBy(x => x.Id).ToList();
            foreach (var item in pattern_list)
            {
                pattern_dict[item.Id] = item.FactorList.FirstOrDefault();
            }
            var pattern_list_json = Yw.JsonHelper.Object2Json(pattern_dict);

          
            // 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;
            }
             

        }


    }
}