using System.Diagnostics;

namespace IStation.Algorithm
{
    /// <summary>
    /// 调度分析辅助类
    /// </summary>
    public partial class AnalysisHelper
    {

        double _frequency_def = 50;
        double _frequency_min = 25;
        double _frequency_max = 50;
        double _frequency_space = 0.1;//频率间隔 

        double _head_space = 0.1;//扬程间隔

        readonly DAL.SQLite.AnalysisCombine _dal_analysis_combine = new();
        readonly DAL.SQLite.AnalysisConclusion _dal_analysis_conclusion = new();
        readonly DAL.SQLite.AnalysisLog _dal_analysis_log = new();
        readonly DAL.SQLite.AnalysisDeviation _dal_analysis_deviation = new();


        /// <summary>
        /// 分析泵组合(目前只分析单泵)
        /// </summary>
        /// <param name="pumps">泵列表</param>
        /// <returns></returns>
        public void AnalysisCombine(List<Model.Pump> pumps)
        {
            InsertAnaLog("开始分析泵组合"); 
            if (pumps == null || pumps.Count < 1)
            {
                InsertAnaLog("分析失败:没有泵数据!");
                return;
            }
            var fre_def = _frequency_def;
            var ana_pump_list = new List<AnaPump>();
            foreach (var pump in pumps)
            {
                if (pump.IsBp)
                {
                    //变频泵
                    var anaPump = new AnaPump(pump, fre_def, _frequency_min, _frequency_max, _frequency_space);
                    if (anaPump.AllowCalc)
                        ana_pump_list.Add(anaPump);
                }
                else
                {
                    //固频泵
                    var anaPump = new AnaPump(pump);
                    if (anaPump.AllowCalc)
                        ana_pump_list.Add(anaPump);
                }
            }
            if (!ana_pump_list.Any())
            {
                InsertAnaLog($"分析进度:没有泵可分析");
                return;
            }
            for (int i = 0; i < ana_pump_list.Count; i++)
            {
                var pump = ana_pump_list[i];
                var ana_frequency_items = pump.AnaFrequencyItems;
                if (ana_frequency_items == null || !ana_frequency_items.Any())
                    continue;

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

                var list = new List<Entity.AnalysisCombine>(pump.AnaFrequencyItems.Count);
                foreach (var freItem in ana_frequency_items)
                {
                    var scheduleCombine = new Entity.AnalysisCombine();
                    scheduleCombine.ID = Yw.YitIdHelper.NextId();
                    scheduleCombine.Pump = freItem.Frequency;
                    scheduleCombine.CurveQH = freItem.CurveQH.ToJson();
                    scheduleCombine.CurveQP = freItem.CurveQP.ToJson();

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

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

        /// <summary>
        /// 分析结论
        /// </summary>
        public void AnalysisConclusion()
        {
            InsertAnaLog($"开始分析泵组合结论!");
            _dal_analysis_conclusion.DeleteAllTable();
            var analysis_combine_table_list = _dal_analysis_combine.GetAllTableName();
            if (analysis_combine_table_list == null || !analysis_combine_table_list.Any())
            {
                InsertAnaLog($"无泵组合表!");
                return;
            }
            var tableCount = analysis_combine_table_list.Count();
            InsertAnaLog($"分析{tableCount}个组合!");
            for (int tableIndex = 0; tableIndex < tableCount; tableIndex++)
            {
                var table_name = analysis_combine_table_list[tableIndex];
                var analysis_combine_list = _dal_analysis_combine.GetNoAnalysisByTableName(table_name);
                if (analysis_combine_list == null || !analysis_combine_list.Any())
                {
                    InsertAnaLog($"分析进度:{table_name},第{tableIndex + 1}个,分析完毕");
                    continue;
                }
                var analysis_combine_list_count = analysis_combine_list.Count();
                var analysis_conclusion_list = new List<List<Entity.AnalysisConclusion>>(analysis_combine_list_count);
                var analysis_combine_ids = new List<long>(analysis_combine_list_count);

                for (int combineIndex = 0; combineIndex < analysis_combine_list_count; combineIndex++)
                {
                    var analysis_combine = analysis_combine_list[combineIndex];
                    var analysis_combine_id = analysis_combine.ID;
                    analysis_combine_ids.Add(analysis_combine_id);
                    var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_combine.CurveQH);
                    var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_combine.CurveQP);
                    var bol = curveQH.GetMinMaxPointY(out double maxY, out double minY);
                    if (!bol)
                        return;
                    var maxHead = Math.Ceiling(maxY);
                    var minHead = Math.Floor(minY);

                    var currentListCount = (int)((maxHead - minHead) / _head_space) + 1;
                    var current_analysis_conclusion_list = new List<Entity.AnalysisConclusion>(currentListCount);
                    for (double head = minHead; head <= maxHead; head += _head_space)
                    {
                        var flow = curveQH.GetInterPointLastX(head);
                        if (!flow.HasValue)
                        {
                            continue;
                        }
                        var analysis_conclusion = new Entity.AnalysisConclusion();
                        analysis_conclusion.ID = Yw.YitIdHelper.NextId();
                        analysis_conclusion.CombineID = analysis_combine_id;
                        analysis_conclusion.Pump = analysis_combine.Pump;
                        analysis_conclusion.Head = head;
                        analysis_conclusion.Flow = flow.Value;
                        analysis_conclusion.Power = curveQP.GetFitPointY(flow.Value);
                        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);
                }
                UpdateAnaStatus(table_name, analysis_combine_ids);
                var list = analysis_conclusion_list.SelectMany(x => x.ToList()).ToList();
                var run_flag = _dal_analysis_combine.GetRunFlag(table_name);
                InsertAnalysisConclusionList(tableIndex + 1, run_flag, list);
            }
        }


        #region Expand 

        /// <summary>
        /// 圆整
        /// </summary> 
        private void Round(Entity.AnalysisConclusion conclusion)
        {
            conclusion.Pump = Math.Round(conclusion.Pump, 1);
            conclusion.Head = Math.Round(conclusion.Head, 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 InsertAnaLog(string info)
        {
            var entity = new Entity.AnalysisLog(info);
            _dal_analysis_log.Insert(entity);
        }

        /// <summary>
        /// 更新分析状态
        /// </summary>
        public bool UpdateAnaStatus(string tableName, List<long> ids)
        {
            if (ids == null || !ids.Any())
            {
                return false;
            }
            return _dal_analysis_combine.UpdateAnaStatus(tableName, ids);
        }

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

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

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

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

        /// <summary>
        /// 插入分析偏差
        /// </summary> 
        private bool InsertAnalysisDeviationList(List<Entity.AnalysisDeviation> analysis_deviation_list)
        {
            var bol = _dal_analysis_deviation.Inserts(analysis_deviation_list);
            return bol;
        }


        #endregion

    }

}