namespace IStation.Algorithm
{

    #region ViewModel

    /// <summary>
    /// 
    /// </summary>
    public class FreCombine
    {
        public FreCombine() { }
        public List<int> Flags { get; set; }
        public int RunCount { get; set; }
        public double Frequency { get; set; }
        public double Flow { get; set; }
        public double Power { get; set; }
    }



    /// <summary>
    /// 分析泵项
    /// </summary>
    public class OptimalCombine
    {
        public OptimalCombine() { }
        public List<int> Flags { get; set; }
        public double Flow { get; set; }
        public double Head { get; set; }
        public double Power { get; set; }
        public List<FreCombine> Combines { get; set; }
    }

    #endregion

    /// <summary>
    /// 调度分析辅助类
    /// </summary>
    public class SchedulingHelper
    {
        double _frequency_def = 50;
        decimal _frequency_min = 25;
        decimal _frequency_max = 50;
        decimal _frequency_space = 0.1m;//频率间隔  

        double _head_space = 0.1;//扬程间隔

        #region RunFlag
        string _falgFrePumpTag = "B";
        string _falgFixPumpTag = "G";
        string _falgSpaceMark = "_";


        string GetRunFlag(int[] flags)
        {
            var runFlag = string.Empty;
            var index = 0;
            var count = flags.Length;
            foreach (var flag in flags)
            {
                runFlag += GetGFlag(flag);
                index++;
                if (index != count)
                {
                    runFlag += _falgSpaceMark;
                }
            }
            return runFlag;
        }

        string GetRunFlag(List<int> flags)
        {
            var runFlag = string.Empty;
            var index = 0;
            var count = flags.Count;
            foreach (var flag in flags)
            {
                runFlag += GetGFlag(flag);
                index++;
                if (index != count)
                {
                    runFlag += _falgSpaceMark;
                }
            }
            return runFlag;
        }

        string GetGFlag(int flag)
        {
            return _falgFrePumpTag + flag;
        }

        #endregion

        DAL.ScheduleCombine _dal = new DAL.ScheduleCombine();
        DAL.ScheduleConclusion _dalScheduleConclusion = new DAL.ScheduleConclusion();
        DAL.ScheduleAnaLog _dalAnaLog = new DAL.ScheduleAnaLog();


        private List<int> _combineFlags1 = new List<int>() { 11, 12, 13, 14, 16, 17, 18 };
        private List<int> _combineFlags2 = new List<int>() { 15 };

        public void Ana(List<Pump> pumps, double taget_flow, double tagetHead)
        {
            tagetHead = Math.Round(tagetHead);
            var pump_flag_list = pumps.Select(x => x.ID).ToList();
            for (int pumpCount = 1; pumpCount <= pumps.Count; pumpCount++)
            {
                var combine_list = PermutationAndCombination<int>.GetCombination(pump_flag_list.ToArray(), pumpCount);
                foreach (var combine in combine_list)
                {
                    List<int> combine_flag_list_part1 = new List<int>();
                    List<int> combine_flag_list_part2 = new List<int>();

                    foreach (var pump in combine)
                    {
                        if (_combineFlags1.Contains(pump))
                        {
                            combine_flag_list_part1.Add(pump);
                        }
                        else
                        {
                            combine_flag_list_part2.Add(pump);
                        }
                    }


                    List<FreCombine> fre_combine_list_part1 = new List<FreCombine>();
                    List<FreCombine> fre_combine_list_part2 = new List<FreCombine>();

                    if (combine_flag_list_part1.Count > 0)
                    {
                        var conclusion_list_dic = new Dictionary<int, List<Entity.ScheduleConclusion>>();
                        foreach (var flag in combine_flag_list_part1)
                        {
                            var runFlag = GetGFlag(flag);
                            if (conclusion_list_dic.ContainsKey(flag))
                                continue;
                            var conclusionList = _dalScheduleConclusion.GetList(runFlag, tagetHead);
                            conclusion_list_dic[flag] = conclusionList;
                        }

                        if (conclusion_list_dic.Count < 1)
                        {
                            continue;
                        }

                        for (decimal fre = _frequency_max; fre >= _frequency_min; fre -= _frequency_space)
                        {
                            var freCombine = new FreCombine();
                            freCombine.Frequency = (double)fre;
                            freCombine.Flags = new List<int>();
                            foreach (var item in conclusion_list_dic)
                            {
                                var conclusion = item.Value.Find(x => x.Pump1 == (double)fre);
                                if (conclusion != null)
                                {
                                    freCombine.Flags.Add(item.Key);
                                    freCombine.Flow += conclusion.Flow;
                                    freCombine.Power += conclusion.Power;
                                    freCombine.RunCount++;
                                }
                            }
                            if (freCombine.Flags.Count < 1)
                                continue;
                            fre_combine_list_part1.Add(freCombine);
                        }




                    }

                    if (combine_flag_list_part2.Count > 0)
                    {
                        var conclusion_list_dic = new Dictionary<int, List<Entity.ScheduleConclusion>>();
                        foreach (var flag in combine_flag_list_part2)
                        {
                            var runFlag = GetGFlag(flag);
                            if (conclusion_list_dic.ContainsKey(flag))
                                continue;
                            var conclusionList = _dalScheduleConclusion.GetList(runFlag, tagetHead);
                            conclusion_list_dic[flag] = conclusionList;
                        }

                        if (conclusion_list_dic.Count < 1)
                        {
                            continue;
                        }

                        for (decimal fre = _frequency_max; fre >= _frequency_min; fre -= _frequency_space)
                        {
                            var freCombine = new FreCombine();
                            freCombine.Frequency = (double)fre;
                            freCombine.Flags = new List<int>();
                            foreach (var item in conclusion_list_dic)
                            {
                                var conclusion = item.Value.Find(x => x.Pump1 == (double)fre);
                                if (conclusion != null)
                                {
                                    freCombine.Flags.Add(item.Key);
                                    freCombine.Flow += conclusion.Flow;
                                    freCombine.Power += conclusion.Power;
                                    freCombine.RunCount++;
                                }
                            }
                            if (freCombine.Flags.Count < 1)
                                continue;
                            fre_combine_list_part2.Add(freCombine);
                        }
                    }


                    var optimalCombine = AnaOptimalCombine(fre_combine_list_part1, fre_combine_list_part2, taget_flow);
                }

            }

        }


        private OptimalCombine AnaOptimalCombine(List<FreCombine> fre_combine_list_part1, List<FreCombine> fre_combine_list_part2, double target_flow)
        {
            double flow_deviation = target_flow;
            double total_power = double.MaxValue;
            double total_flow = double.MaxValue;

            FreCombine optimal_combine_part1 = null;
            FreCombine optimal_combine_part2 = null;
            for (int Index_part1 = 0; Index_part1 < fre_combine_list_part1.Count; Index_part1++)
            {
                for (int Index_part2 = 0; Index_part2 < fre_combine_list_part2.Count; Index_part2++)
                {
                    var fre_combine1 = fre_combine_list_part1[Index_part1];
                    var fre_combine2 = fre_combine_list_part2[Index_part2];

                    var current_flow = fre_combine1.Flow + fre_combine2.Flow;
                    var current_power = fre_combine1.Power + fre_combine2.Power;

                    var diff_flow = Math.Abs(current_flow - target_flow);
                    if (diff_flow < flow_deviation)
                    {
                        optimal_combine_part1 = fre_combine1;
                        optimal_combine_part2 = fre_combine2;
                        total_power = fre_combine1.Power + fre_combine2.Power;
                        total_flow = current_flow;
                        flow_deviation = diff_flow;
                    }

                    if (diff_flow < target_flow * 0.01 && current_power < total_power)
                    {
                        optimal_combine_part1 = fre_combine1;
                        optimal_combine_part2 = fre_combine2;
                        total_power = fre_combine1.Power + fre_combine2.Power;
                        total_flow = current_flow;
                    }

                }
            }
            if (optimal_combine_part1 == null && optimal_combine_part2 == null)
                return default;
            var optimal_combine = new OptimalCombine();
            optimal_combine.Combines = new List<FreCombine>();
            if (optimal_combine_part1 != null)
            {
                optimal_combine.Combines.Add(optimal_combine_part1);
            }
            if (optimal_combine_part2 != null)
            {
                optimal_combine.Combines.Add(optimal_combine_part2);
            }
            optimal_combine.Flow = total_flow;
            optimal_combine.Power = total_power;
            return optimal_combine;
        }

        /// <summary>
        /// 插入分析日志
        /// </summary> 
        private void InsertAnaLog(string info)
        {
            var entity = new Entity.ScheduleAnaLog(info);
            _dalAnaLog.Insert(entity);
        }


        /// <summary>
        /// 判断表是否存在
        /// </summary>
        public bool ExistTable(string runFlag)
        {
            return _dal.ExistTable(runFlag);
        }

    }
}