using System.Diagnostics;

namespace IStation.Algorithm
{
    /// <summary>
    /// 调度分析辅助类
    /// </summary>
    public partial class AnalysisHelper
    {
        private readonly double _frequency_def = 50;
        private readonly double _frequency_min = 25;
        private readonly double _frequency_max = 50;
        private readonly double _frequency_space = 0.10;//频率间隔  
        private readonly decimal _head_space = 0.1m;//扬程间隔

        private readonly DAL.SQLite.AnalysisPump _dal_analysis_pump = new();
        private readonly DAL.SQLite.AnalysisParameter _dal_analysis_conclusion = new();
        private readonly DAL.SQLite.AnalysisFactor _dal_analysis_factor = new();


        /// <summary>
        /// 分析泵
        /// </summary>
        /// <param name="pumps">泵列表</param>
        /// <returns></returns>
        public void AnalysisPump(List<Model.Pump> pumps)
        {
            InsertLog("开始分析泵组合");
            if (pumps == null || pumps.Count < 1)
            {
                InsertLog("分析失败:没有泵数据!");
                return;
            }

            var all_analysis_factor_list = _dal_analysis_factor.GetAll();
            var fre_def = _frequency_def;
            var analysis_pump_list = new List<AnaPump>();
            foreach (var pump in pumps)
            {
                var pump_factor_list = all_analysis_factor_list?.Where(x => x.Flag == pump.Flag).ToList();
                if (pump.IsBp)
                {
                    //变频泵
                    var fre_head_diff_avg_dict = pump_factor_list?.ToDictionary(x => x.Hz, y => y.HeadDeviation);
                    var analysisPump = new AnaPump(pump, fre_def, _frequency_min, _frequency_max, _frequency_space, fre_head_diff_avg_dict);
                    if (analysisPump.AllowCalc)
                        analysis_pump_list.Add(analysisPump);
                }
                else
                {
                    //固频泵
                    var analysisPump = new AnaPump(pump);
                    if (analysisPump.AllowCalc)
                        analysis_pump_list.Add(analysisPump);
                }
            }
            if (!analysis_pump_list.Any())
            {
                InsertLog($"分析进度:没有泵可分析");
                return;
            }
            for (int i = 0; i < analysis_pump_list.Count; i++)
            {
                var pump = analysis_pump_list[i];
                var analysis_frequency_items = pump.AnaFrequencyItems;
                if (analysis_frequency_items == null || !analysis_frequency_items.Any())
                    continue;

                var run_flag = RunFlagHelper.GetRunFlag(pump.Flag, pump.IsBp);
                InsertLog($"分析进度:第{i + 1}台泵");

                var list = new List<Entity.AnalysisPump>(pump.AnaFrequencyItems.Count);
                foreach (var freItem in analysis_frequency_items)
                {
                    var analysis_pump = new Entity.AnalysisPump();
                    analysis_pump.ID = Yw.YitIdHelper.NextId();
                    analysis_pump.Flag = pump.Flag;
                    analysis_pump.Hz = freItem.Frequency;
                    analysis_pump.CurveQH = freItem.CurveQH.ToJson();
                    analysis_pump.CurveQP = freItem.CurveQP.ToJson();

                    freItem.CurveQH.GetMinMaxPointY(out double maxHead, out double minHead);
                    analysis_pump.MinFlow = Math.Round(freItem.CurveQH.Min, 4);
                    analysis_pump.MaxFlow = Math.Round(freItem.CurveQH.Max, 4);
                    analysis_pump.MaxHead = Math.Round(maxHead, 4);
                    analysis_pump.MinHead = Math.Round(minHead, 4);
                    list.Add(analysis_pump);
                }
                InsertList(i + 1, run_flag, list);
            }

            InsertLog($"分析进度:{pumps.Count}台泵,分析完毕!");
        }


        /// <summary>
        /// 分析参数
        /// </summary>
        public void AnalysisParameter(List<Model.Pump> pumps)
        {
            InsertLog($"开始分析泵结论!");
            if (pumps == null || pumps.Count < 1)
            {
                InsertLog("分析失败:没有泵数据!");
                return;
            }

            _dal_analysis_conclusion.DeleteAllTable();
            for (int pump_index = 0; pump_index < pumps.Count; pump_index++)
            {
                var pump = pumps[pump_index];
                var flag = pump.Flag;
                var run_flag = RunFlagHelper.GetRunFlag(flag, pump.IsBp);
                var table_name = _dal_analysis_pump.GetTableName(run_flag);
                var analysis_pump_list = _dal_analysis_pump.GetAllByTableName(table_name);
                if (analysis_pump_list == null || !analysis_pump_list.Any())
                {
                    InsertLog($"分析进度:{table_name},第{pump_index + 1}个,分析完毕");
                    continue;
                }

                var analysis_pump_list_count = analysis_pump_list.Count();
                var analysis_conclusion_list = new List<List<Entity.AnalysisParameter>>(analysis_pump_list_count);
                for (int analysis_pump_index = 0; analysis_pump_index < analysis_pump_list_count; analysis_pump_index++)
                {
                    var analysis_pump = analysis_pump_list[analysis_pump_index];
                    var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQH);
                    var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQP);
                    var bol = curveQH.GetMinMaxPointY(out double maxY, out double minY);
                    if (!bol)
                        throw new Exception("曲线异常");

                    decimal max_head = (decimal)Math.Ceiling(maxY);
                    decimal min_head = (decimal)Math.Floor(minY);

                    var current_list_count = (int)((max_head - min_head) / _head_space) + 1;
                    var current_analysis_conclusion_list = new List<Entity.AnalysisParameter>(current_list_count);
                    for (decimal head = min_head; head <= max_head; head += _head_space)
                    {
                        var flow = curveQH.GetInterPointLastX((double)head) ?? 0;
                        if (flow < 1)
                        {
                            continue;
                        }

                        double differV = 0;
                        if (pump.Oc != null)
                        {
                            //1输和2输都是用的进口液位，不考虑进口口径
                            differV = PumpCalculateHelper.CalculateOtherPress(flow, null, pump.Oc, null, null);
                        }

                        var analysis_conclusion = new Entity.AnalysisParameter();
                        analysis_conclusion.ID = Yw.YitIdHelper.NextId();
                        analysis_conclusion.PumpID = analysis_pump.ID;
                        analysis_conclusion.Hz = analysis_pump.Hz;
                        analysis_conclusion.Head = (double)head;
                        analysis_conclusion.PressureDiff = (double)head - differV;
                        analysis_conclusion.Flow = flow;
                        analysis_conclusion.Power = curveQP.GetFitPointY(flow);
                        analysis_conclusion.UWP = PumpCalculateHelper.CalculateUWP(analysis_conclusion.Power, analysis_conclusion.Flow, analysis_conclusion.Head);
                        analysis_conclusion.WP = PumpCalculateHelper.CalculateWP(analysis_conclusion.Power, analysis_conclusion.Flow);

                        Round(analysis_conclusion);
                        current_analysis_conclusion_list.Add(analysis_conclusion);
                    }
                    analysis_conclusion_list.Add(current_analysis_conclusion_list);
                }
                var list = analysis_conclusion_list.SelectMany(x => x.ToList()).ToList();
                InsertList(pump_index + 1, run_flag, list);
            }
        }


        /// <summary>
        /// 分析参数
        /// </summary>
        public void Test(List<Model.Pump> pumps)
        {
            if (pumps == null || pumps.Count < 1)
            {
                return;
            }

            _dal_analysis_conclusion.DeleteAllTable();
            for (int pump_index = 0; pump_index < pumps.Count; pump_index++)
            {
                var pump = pumps[pump_index];
                var flag = pump.Flag;
                var run_flag = RunFlagHelper.GetRunFlag(flag, pump.IsBp);
                var table_name = _dal_analysis_pump.GetTableName(run_flag);
                var analysis_pump_list = _dal_analysis_pump.GetAllByTableName(table_name);
                if (analysis_pump_list == null || !analysis_pump_list.Any())
                {
                    continue;
                }

                var analysis_pump_list_count = analysis_pump_list.Count();
                var analysis_conclusion_list = new List<List<Entity.AnalysisParameter>>(analysis_pump_list_count);
                for (int analysis_pump_index = 0; analysis_pump_index < analysis_pump_list_count; analysis_pump_index++)
                {
                    var analysis_pump = analysis_pump_list[analysis_pump_index];
                    var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQH);
                    var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQP);
                    var bol = curveQH.GetMinMaxPointY(out double maxY, out double minY);
                    if (!bol)
                        throw new Exception("曲线异常");

                    decimal max_head = (decimal)Math.Ceiling(maxY);
                    decimal min_head = (decimal)Math.Floor(minY);

                    decimal head_space = 0.01m;
                    var current_list_count = (int)((max_head - min_head) / head_space) + 1;
                    var current_analysis_conclusion_list = new List<Entity.AnalysisParameter>(current_list_count);
                    for (decimal head = min_head; head <= max_head; head += head_space)
                    {
                        var flow = curveQH.GetInterPointLastX((double)head) ?? 0;
                        if (flow < 1)
                        {
                            continue;
                        }

                        double differV = 0;
                        if (pump.Oc != null)
                        {
                            differV = PumpCalculateHelper.CalculateOtherPress(flow, pump.Ic, pump.Oc, null, null);
                        }

                        var analysis_conclusion = new Entity.AnalysisParameter();
                        analysis_conclusion.ID = Yw.YitIdHelper.NextId();
                        analysis_conclusion.PumpID = analysis_pump.ID;
                        analysis_conclusion.Hz = analysis_pump.Hz;
                        analysis_conclusion.Head = (double)head;
                        analysis_conclusion.PressureDiff = (double)head - differV;
                        analysis_conclusion.Flow = flow;
                        analysis_conclusion.Power = curveQP.GetFitPointY(flow);
                        analysis_conclusion.UWP = PumpCalculateHelper.CalculateUWP(analysis_conclusion.Power, analysis_conclusion.Flow, analysis_conclusion.Head);
                        analysis_conclusion.WP = PumpCalculateHelper.CalculateWP(analysis_conclusion.Power, analysis_conclusion.Flow);


                        analysis_conclusion.Hz = Math.Round(analysis_conclusion.Hz, 1);
                        analysis_conclusion.Head = Math.Round(analysis_conclusion.Head, 2);
                        analysis_conclusion.PressureDiff = Math.Round(analysis_conclusion.PressureDiff, 2);
                        analysis_conclusion.Flow = Math.Round(analysis_conclusion.Flow, 1);
                        analysis_conclusion.Power = Math.Round(analysis_conclusion.Power, 1);
                        analysis_conclusion.WP = Math.Round(analysis_conclusion.WP, 1);
                        analysis_conclusion.UWP = Math.Round(analysis_conclusion.UWP, 1);
                        current_analysis_conclusion_list.Add(analysis_conclusion);
                    }
                    analysis_conclusion_list.Add(current_analysis_conclusion_list);
                }
                var list = analysis_conclusion_list.SelectMany(x => x.ToList()).ToList();
                InsertList(pump_index + 1, run_flag, list);
            }
        }


        #region Expand 

        /// <summary>
        /// 圆整
        /// </summary> 
        private void Round(Entity.AnalysisParameter conclusion)
        {
            conclusion.Hz = Math.Round(conclusion.Hz, 1);
            conclusion.Head = Math.Round(conclusion.Head, 1);
            conclusion.PressureDiff = Math.Round(conclusion.PressureDiff, 1);
            conclusion.Flow = Math.Round(conclusion.Flow, 1);
            conclusion.Power = Math.Round(conclusion.Power, 1);
            conclusion.WP = Math.Round(conclusion.WP, 1);
            conclusion.UWP = Math.Round(conclusion.UWP, 1);
        }

        /// <summary>
        /// 插入日志
        /// </summary> 
        private void InsertLog(string info)
        {
            LogHelper.Info(info);
        }

        /// <summary>
        /// 插入分析组合列表
        /// </summary> 
        public void InsertList(int index, string runFlag, List<Entity.AnalysisPump> list)
        {
            string log;
            if (list == null || !list.Any())
            {
                log = $"{runFlag}:下标:{index},无数据";
                InsertLog(log);
                return;
            }

            var sw = Stopwatch.StartNew();
            _dal_analysis_pump.BulkInsertsEx(runFlag, list);
            log = $"{runFlag}:下标:{index},数量:{list.Count},插入耗时:{sw.ElapsedMilliseconds / 1000}m";
            InsertLog(log);
        }

        /// <summary>
        /// 插入分析参数列表
        /// </summary> 
        public void InsertList(int index, string runFlag, List<Entity.AnalysisParameter> list)
        {
            string log;
            if (list == null || !list.Any())
            {
                log = $"{runFlag}:下标:{index},无数据";
                InsertLog(log);
                return;
            }

            var sw = Stopwatch.StartNew();
            _dal_analysis_conclusion.BulkInsertsEx(runFlag, list);
            log = $"分析进度:{runFlag},下标:{index},数量:{list.Count},插入耗时:{sw.ElapsedMilliseconds / 1000}m";
            InsertLog(log);
        }

        #endregion

    }

}


///// <summary>
///// 分析参数
///// </summary>
//public void Test_bak(List<Model.Pump> pumps)
//{
//    if (pumps == null || pumps.Count < 1)
//    {
//        return;
//    }

//    _dal_analysis_conclusion.DeleteAllTable();
//    for (int pump_index = 0; pump_index < pumps.Count; pump_index++)
//    {
//        var pump = pumps[pump_index];
//        var flag = pump.Flag;
//        var run_flag = RunFlagHelper.GetRunFlag(flag, pump.IsBp);
//        var table_name = _dal_analysis_pump.GetTableName(run_flag);
//        var analysis_pump_list = _dal_analysis_pump.GetAllByTableName(table_name);
//        if (analysis_pump_list == null || !analysis_pump_list.Any())
//        {
//            continue;
//        }

//        var analysis_pump_list_count = analysis_pump_list.Count();
//        var analysis_conclusion_list = new List<List<Entity.AnalysisParameter>>(analysis_pump_list_count);
//        for (int analysis_pump_index = 0; analysis_pump_index < analysis_pump_list_count; analysis_pump_index++)
//        {
//            var analysis_pump = analysis_pump_list[analysis_pump_index];
//            var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQH);
//            var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQP);
//            var bol = curveQH.GetMinMaxPointY(out double maxY, out double minY);
//            if (!bol)
//                throw new Exception("曲线异常");

//            var min_flow = curveQH.Min;
//            var max_flow = curveQH.Max;

//            var min_flow_head = curveQH.GetFitPointY(min_flow);
//            var max_flow_head = curveQH.GetFitPointY(max_flow);

//            var min_flow_diffV = PumpCalculateHelper.CalculateOtherPress(min_flow, pump.Ic, pump.Oc, null, null);
//            var max_flow_diffV = PumpCalculateHelper.CalculateOtherPress(max_flow, pump.Ic, pump.Oc, null, null);

//            decimal min_flow_pressure_diff = (decimal)(min_flow_head - min_flow_diffV);
//            decimal max_flow_pressure_diff = (decimal)(max_flow_head - max_flow_diffV);

//            decimal pressure_space = 0.1m;
//            for (decimal pressure_diff = max_flow_pressure_diff; pressure_diff < max_flow_pressure_diff; pressure_diff += pressure_space)
//            {

//            }

//            var max_head = Math.Ceiling(maxY);
//            var min_head = Math.Floor(minY);

//            //var curve_max_flow= max.X;
//            //var curve_min_flow= min.X;

//            //var curve_max_diffV = PumpCalculateHelper.CalculateOtherPress(curve_max_flow, pump.Ic, pump.Oc, null, null);
//            //var curve_min_diffV = PumpCalculateHelper.CalculateOtherPress(curve_min_flow, pump.Ic, pump.Oc, null, null);

//            //var curve_max_pressure_diff = max_head - curve_max_diffV;
//            //var curve_min_pressure_diff = min_head - curve_min_diffV;




//            var max_diffV = PumpCalculateHelper.CalculateOtherPress(min_flow, pump.Ic, pump.Oc, null, null);
//            var min_diffV = PumpCalculateHelper.CalculateOtherPress(max_flow, pump.Ic, pump.Oc, null, null);

//            var max_pressure_diff = max_head - max_diffV;
//            var min_pressure_diff = min_head - min_diffV;
//            //max_pressure_diff = Math.Round(max_pressure_diff);

//            var current_list_count = (int)((max_head - min_head) / _head_space) + 1;
//            var current_analysis_conclusion_list = new List<Entity.AnalysisParameter>(current_list_count);
//            for (double head = min_head; head <= max_head; head += _head_space)
//            {
//                var flow = curveQH.GetInterPointLastX(head) ?? 0;
//                if (flow < 1)
//                {
//                    continue;
//                }

//                double diffV = 0;
//                if (pump.Oc != null)
//                {
//                    diffV = PumpCalculateHelper.CalculateOtherPress(flow, pump.Ic, pump.Oc, null, null);
//                }

//                var analysis_conclusion = new Entity.AnalysisParameter();
//                analysis_conclusion.ID = Yw.YitIdHelper.NextId();
//                analysis_conclusion.PumpID = analysis_pump.ID;
//                analysis_conclusion.Hz = analysis_pump.Hz;
//                analysis_conclusion.Head = head;
//                analysis_conclusion.PressureDiff = head - diffV;
//                analysis_conclusion.Flow = flow;
//                analysis_conclusion.Power = curveQP.GetFitPointY(flow);
//                analysis_conclusion.UWP = PumpCalculateHelper.CalculateUWP(analysis_conclusion.Power, analysis_conclusion.Flow, analysis_conclusion.Head);
//                analysis_conclusion.WP = PumpCalculateHelper.CalculateWP(analysis_conclusion.Power, analysis_conclusion.Flow);

//                Round(analysis_conclusion);
//                current_analysis_conclusion_list.Add(analysis_conclusion);
//            }
//            analysis_conclusion_list.Add(current_analysis_conclusion_list);
//        }
//        var list = analysis_conclusion_list.SelectMany(x => x.ToList()).ToList();
//        InsertList(pump_index + 1, run_flag, list);
//    }

//}


///// <summary>
///// 分析参数
///// </summary>
//public void AnalysisParameterBak(List<Model.Pump> pumps)
//{
//    InsertLog($"开始分析泵结论!");
//    if (pumps == null || pumps.Count < 1)
//    {
//        InsertLog("分析失败:没有泵数据!");
//        return;
//    }

//    _dal_analysis_conclusion.DeleteAllTable();
//    var analysis_pump_table_list = _dal_analysis_pump.GetAllTableName();
//    if (analysis_pump_table_list == null || !analysis_pump_table_list.Any())
//    {
//        InsertLog($"无分析泵表!");
//        return;
//    }
//    var flag_pump_dict = pumps.ToDictionary(x => x.Flag, x => x);
//    var tableCount = analysis_pump_table_list.Count();
//    InsertLog($"分析{tableCount}台泵结论!");
//    for (int tableIndex = 0; tableIndex < tableCount; tableIndex++)
//    {
//        var table_name = analysis_pump_table_list[tableIndex];
//        var analysis_pump_list = _dal_analysis_pump.GetAllByTableName(table_name);
//        if (analysis_pump_list == null || !analysis_pump_list.Any())
//        {
//            InsertLog($"分析进度:{table_name},第{tableIndex + 1}个,分析完毕");
//            continue;
//        }
//        var analysis_pump_list_count = analysis_pump_list.Count();
//        var analysis_conclusion_list = new List<List<Entity.AnalysisParameter>>(analysis_pump_list_count);

//        for (int analysis_pump_index = 0; analysis_pump_index < analysis_pump_list_count; analysis_pump_index++)
//        {
//            var analysis_pump = analysis_pump_list[analysis_pump_index];
//            var pump = flag_pump_dict[analysis_pump.Flag];
//            var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQH);
//            var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQP);
//            var bol = curveQH.GetMinMaxPointY(out double maxY, out double minY);
//            if (!bol)
//                return;
//            var max_head = Math.Ceiling(maxY);
//            var min_head = Math.Floor(minY);

//            var current_list_count = (int)((max_head - min_head) / _head_space) + 1;
//            var current_analysis_conclusion_list = new List<Entity.AnalysisParameter>(current_list_count);
//            for (double head = min_head; head <= max_head; head += _head_space)
//            {
//                var flow = curveQH.GetInterPointLastX(head) ?? 0;
//                if (flow < 1)
//                {
//                    continue;
//                }

//                double differV = 0;
//                if (pump.Oc != null)
//                {
//                    differV = PumpCalculateHelper.CalculateOtherPress(flow, pump.Ic, pump.Oc, null, null);
//                }

//                var analysis_conclusion = new Entity.AnalysisParameter();
//                analysis_conclusion.ID = Yw.YitIdHelper.NextId();
//                analysis_conclusion.PumpID = analysis_pump.ID;
//                analysis_conclusion.Hz = analysis_pump.Hz;
//                analysis_conclusion.Head = head;
//                analysis_conclusion.PressureDiff = head - differV;
//                analysis_conclusion.Flow = flow;
//                analysis_conclusion.Power = curveQP.GetFitPointY(flow);
//                analysis_conclusion.UWP = PumpCalculateHelper.CalculateUWP(analysis_conclusion.Power, analysis_conclusion.Flow, analysis_conclusion.Head);
//                analysis_conclusion.WP = PumpCalculateHelper.CalculateWP(analysis_conclusion.Power, analysis_conclusion.Flow);

//                Round(analysis_conclusion);
//                current_analysis_conclusion_list.Add(analysis_conclusion);
//            }
//            analysis_conclusion_list.Add(current_analysis_conclusion_list);
//        }
//        var list = analysis_conclusion_list.SelectMany(x => x.ToList()).ToList();
//        var run_flag = _dal_analysis_pump.GetRunFlag(table_name);
//        InsertList(tableIndex + 1, run_flag, list);
//    }
//}