using IStation.Epanet;
using IStation.Epanet.Enums;

namespace IStation.Hydraulic
{
    /// <summary>
    /// 模型验证辅助类
    /// </summary>
    public partial class ModeVerifyHelper
    {


        /// <summary>
        /// 实时验证
        /// </summary>
        /// <param name="verify_id">验证标识</param>
        /// <param name="verify_time">验证时间</param>
        /// <param name="verify_file_path">验证模型文件</param>
        /// <param name="zy_scada_list">ZyScada数据列表</param>
        /// <param name="pump_pattern_custom_dict">自定义泵模式</param>
        /// <returns></returns>
        public static List<Model.HydraulicModelRecord> Verify(
            long verify_id,
            DateTime verify_time,
            string verify_file_path,
            List<Model.ZyScada> zy_scada_list,
            Dictionary<string, double?> pump_pattern_custom_dict = null)
        {
            var log_title = "初始化验证数据";
            var log_msg = string.Empty;
            if (zy_scada_list == null || !zy_scada_list.Any())
            {
                log_msg = "zy_scada_list 数据为空!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }

            var pump_nr_dict = GlobalHelper.ModelPumpNrDict;
            var pattern_id_mapping_dict = GlobalHelper.ModelPatternIdMappingDict;
            var flow_id_mapping_dict = GlobalHelper.ModelFlowIdMappingDict;
            var pressure_id_mapping_dict = GlobalHelper.ModelPressureIdMappingDict;
            var pressure_id_kPa_list = GlobalHelper.ModelPressureIdkPaList;

            var pattern_dict = new Dictionary<string, float[]>();
            var scada_dict = new Dictionary<string, double>();

            var exist_pump_pattern_custom_dict = pump_pattern_custom_dict != null && pump_pattern_custom_dict.Any();

            #region 初始化 pattern_dict scada_dict

            foreach (var zy_scada in zy_scada_list)
            {
                var tag = zy_scada.Code;
                var value = zy_scada.Value;

                #region Pattern

                foreach (var item in pattern_id_mapping_dict)
                {
                    if (item.Value != tag)
                        continue;
                    var pattern_id = item.Key;
                    var factor = value ?? 0;
                    if (exist_pump_pattern_custom_dict)
                    {
                        if (pump_pattern_custom_dict.ContainsKey(pattern_id))
                        {
                            factor = pump_pattern_custom_dict[pattern_id] ?? 0;
                        }
                    }
                    else
                    {
                        if (value.HasValue && pump_nr_dict.ContainsKey(pattern_id))
                        {
                            factor /= pump_nr_dict[pattern_id];
                            factor = factor < 0 ? 0 : factor;
                        }
                    }

                    pattern_dict.Add(pattern_id, new float[] { (float)factor });
                }

                #endregion

                #region Scada

                foreach (var item in flow_id_mapping_dict)
                {
                    if (item.Value != tag)
                        continue;
                    scada_dict.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);
                    scada_dict.Add(tag, pressure_value);
                }
                #endregion
            }

            #endregion


            var hydraulic_record_list = Verify(verify_id, verify_time, verify_file_path, flow_id_mapping_dict, pressure_id_mapping_dict, pattern_dict, scada_dict);
            return hydraulic_record_list;
        }






        /// <summary>
        /// 实时验证
        /// </summary>
        /// <param name="verify_id">验证标识</param>
        /// <param name="verify_time">验证时间</param>
        /// <param name="verify_file_path">验证模型文件</param>
        /// <param name="flow_id_mapping_dict">流量Scada标识字典</param>
        /// <param name="pressure_id_mapping_dict">压力Scada标识字典</param>
        /// <param name="pattern_dict">模式数据</param>
        /// <param name="scada_dict">Scada数据</param>
        /// <returns></returns>
        public static List<Model.HydraulicModelRecord> Verify(
            long verify_id,
            DateTime verify_time,
            string verify_file_path,
            Dictionary<string, string> flow_id_mapping_dict,
            Dictionary<string, string> pressure_id_mapping_dict,
            Dictionary<string, float[]> pattern_dict,
            Dictionary<string, double> scada_dict)
        {
            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_dict == null || !pattern_dict.Any())
            {
                log_msg = "模式数据为空!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }
            if (scada_dict == null || !scada_dict.Any())
            {
                log_msg = "Scada数据为空!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }

            var err = EpanetMethods.ENopen(verify_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_dict)
            {
                var pattern_id = pattern.Key;
                var pattern_factor_array = pattern.Value;
                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 = $"{verify_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);

            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_dict[scada_id];
                    EpanetMethods.ENgetlinkvalue(link_index, LinkValue.Flow, out float model_value);
                    model_value = Math.Abs(model_value);

                    var record = new IStation.Model.HydraulicModelRecord
                    {
                        VerificationID = verify_id,
                        Time = verify_time,
                        ModelId = model_id,
                        ScadaId = scada_id,
                        ValueType = IStation.eValueType.Flow,
                        ModelValue = (double)model_value,
                        ScadaValue = scada_value
                    };
                    record.DifferenceValue = record.ScadaValue - record.ModelValue;
                    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_dict[scada_id];

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

                    var record = new IStation.Model.HydraulicModelRecord
                    {
                        VerificationID = verify_id,
                        Time = verify_time,
                        ModelId = model_id,
                        ScadaId = scada_id,
                        ValueType = IStation.eValueType.Head,
                        ModelValue = (double)model_value,
                        ScadaValue = scada_value
                    };
                    record.DifferenceValue = record.ScadaValue - record.ModelValue;
                    hydraulic_record_list.Add(record);
                }
            }

            EpanetMethods.ENcloseH();
            return hydraulic_record_list;
        }


        /// <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 = "流量标签字典为空!";
                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 (day_value_list == null || !day_value_list.Any())
            {
                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_msg = "初始化成功";
            Log.Info(verify_id, log_title, 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();
                        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 = $"{day_value.Year}_{day_value.Month}_{day_value.Day}:模式初始化失败!";
                    Log.Info(verify_id, log_title, 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;
                        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.ModelValue = (double)model_value;
                                record.ScadaValue = scada_value;
                                if (record.ModelValue.HasValue)
                                    record.ModelValue = Math.Abs(record.ModelValue.Value);
                                record.DifferenceValue = record.ScadaValue - record.ModelValue;
                                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.ModelValue = (double)model_value;
                                record.ScadaValue = scada_value;
                                if (record.ModelValue.HasValue)
                                    record.ModelValue = Math.Abs(record.ModelValue.Value);
                                record.DifferenceValue = record.ScadaValue - record.ModelValue;
                                hydraulic_record_list.Add(record);
                            }
                        }
                    }

                    EpanetMethods.ENnextH(out model_time_step);

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


    }

}