using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IStation.Model.Monitor
{
    /// <summary>
    /// 公式类型
    /// </summary>
    public class FormulaType
    {
        /// <summary>
        /// 计算-单一映射
        /// </summary>
        public const string Calculation_SingleMapping = "Calculation_单一映射";

        /// <summary>
        /// 计算- 比较映射
        /// </summary>
        public const string Calculation_CompareMapping = "Calculation_比较映射";

        /// <summary>
        /// 计算-区间映射
        /// </summary>
        public const string Calculation_RangeMapping = "Calculation_区间映射";

        /// <summary>
        /// 计算-一元系数
        /// </summary>
        public const string Calculation_OnceRatio = "Calculation_一元系数";

        /// <summary>
        /// 计算-二元系数
        /// </summary>
        public const string Calculation_TwiceRatio = "Calculation_二元系数";

        /// <summary>
        /// 计算-运行状态
        /// </summary>
        public const string Calculation_RunStatus = "Calculation_运行状态";

        /// <summary>
        /// 计算-和值
        /// </summary>
        public const string Calculation_Sum = "Calculation_和值";

        /// <summary>
        /// 计算-差值
        /// </summary>
        public const string Calculation_Diff = "Calculation_差值";

        /// <summary>
        /// 计算-数值累积
        /// </summary>
        public const string Calculation_NumericAccumulate = "Calculation_数值累积";

        /// <summary>
        /// 计算-枚举累积
        /// </summary>
        public const string Calculation_EnumAccumulate = "Calculation_枚举累积";

        /// <summary>
        /// 计算-效率
        /// </summary>
        public const string Calculation_E = "Calculation_效率";

        /// <summary>
        /// 计算-千吨能耗
        /// </summary>
        public const string Calculation_WP = "Calculation_千吨能耗";

        /// <summary>
        /// 计算-单位能耗
        /// </summary>
        public const string Calculation_UWP = "Calculation_单位能耗";

        /// <summary>
        ///  计算-常量
        /// </summary>
        public const string Calculation_Const = "Calculation_常量";


        /// <summary>
        /// 统计-最大值
        /// </summary>
        public const string Statistics_Max = "Statistics_最大值";
        /// <summary>
        /// 统计-最小值
        /// </summary>
        public const string Statistics_Min = "Statistics_最小值";
        /// <summary>
        /// 统计-均值
        /// </summary>
        public const string Statistics_Avg = "Statistics_均值";
        /// <summary>
        /// 统计-差值
        /// </summary>
        public const string Statistics_Diff = "Statistics_差值";
        /// <summary>
        /// 统计-和值
        /// </summary>
        public const string Statistics_Sum = "Statistics_和值";




        /// <summary>
        /// 获取显示字典
        /// </summary>
        public static Dictionary<string, string> GetDisplayDict()
        {
            var dict = new Dictionary<string, string>();

            dict.Add("Calculation_单一映射", "单一映射计算");
            dict.Add("Calculation_比较映射", "比较映射计算");
            dict.Add("Calculation_区间映射", "区间映射计算");

            dict.Add("Calculation_一元系数", "一元系数计算");
            dict.Add("Calculation_二元系数", "二元系数计算");
            dict.Add("Calculation_运行状态", "运行状态计算");

            dict.Add("Calculation_和值", "和值计算");
            dict.Add("Calculation_差值", "差值计算");
            dict.Add("Calculation_数值累积", "数值累积计算");
            dict.Add("Calculation_枚举累积", "枚举累积计算");

            dict.Add("Calculation_效率", "效率计算");
            dict.Add("Calculation_千吨能耗", "千吨能耗计算");
            dict.Add("Calculation_单位能耗", "单位能耗计算");

            dict.Add("Calculation_常量", "常量计算");

            dict.Add("Statistics_最大值", "最大值统计");
            dict.Add("Statistics_最小值", "最小值统计");
            dict.Add("Statistics_均值", "均值统计");
            dict.Add("Statistics_差值", "差值统计");
            dict.Add("Statistics_和值", "和值统计");



            return dict;
        }

        /// <summary>
        /// 获取显示名称
        /// </summary>
        public static string GetDisplayName(string formulaType)
        {
            if (string.IsNullOrEmpty(formulaType))
                return string.Empty;
            switch (formulaType)
            {
                case Calculation_SingleMapping: return "单一映射计算";
                case Calculation_CompareMapping: return "比较映射计算";
                case Calculation_RangeMapping: return "区间映射计算";

                case Calculation_OnceRatio: return "一元系数计算";
                case Calculation_TwiceRatio: return "二元系数计算";
                case Calculation_RunStatus: return "运行状态计算";

                case Calculation_Sum: return "和值计算";
                case Calculation_Diff: return "差值计算";
                case Calculation_NumericAccumulate: return "数值累积计算";
                case Calculation_EnumAccumulate: return "枚举累积计算";

                case Calculation_E: return "效率计算";
                case Calculation_WP: return "千吨能耗计算";
                case Calculation_UWP: return "单位能耗计算";

                case Calculation_Const: return "常量计算";

                case Statistics_Max: return "最大值统计";
                case Statistics_Min: return "最小值统计";
                case Statistics_Avg: return "均值统计";
                case Statistics_Diff: return "差值统计";
                case Statistics_Sum: return "和值统计";

                default: return string.Empty;
            }
        }

        /// <summary>
        /// 通过计划类型获取
        /// </summary>
        public static Dictionary<string, string> GetDictByCronType(eCronType cronType)
        {
            var dict = new Dictionary<string, string>();
            switch (cronType)
            {
                case eCronType.Real:
                    {
                        dict.Add("Calculation_单一映射", "单一映射计算");
                        dict.Add("Calculation_比较映射", "比较映射计算");
                        dict.Add("Calculation_区间映射", "区间映射计算");

                        dict.Add("Calculation_一元系数", "一元系数计算");
                        dict.Add("Calculation_二元系数", "二元系数计算");
                        dict.Add("Calculation_自定义运行状态", "运行状态计算");

                        dict.Add("Calculation_和值", "和值计算");
                        dict.Add("Calculation_差值", "差值计算");
                        dict.Add("Calculation_数值累积", "数值累积计算");
                        dict.Add("Calculation_枚举累积", "枚举累积计算");

                        dict.Add("Calculation_效率", "效率计算");
                        dict.Add("Calculation_千吨能耗", "千吨能耗计算");
                        dict.Add("Calculation_单位能耗", "单位能耗计算");

                        dict.Add("Calculation_常量", "常量计算");
                    }
                    break;
                case eCronType.EachHour:
                    {
                        dict.Add("Statistics_最大值", "最大值统计");
                        dict.Add("Statistics_最小值", "最小值统计");
                        dict.Add("Statistics_均值", "均值统计");
                        dict.Add("Statistics_差值", "差值统计");
                        dict.Add("Statistics_和值", "和值统计");
                    }
                    break;
                case eCronType.EachDay:
                    {
                        dict.Add("Statistics_最大值", "最大值统计");
                        dict.Add("Statistics_最小值", "最小值统计");
                        dict.Add("Statistics_均值", "均值统计");
                        dict.Add("Statistics_差值", "差值统计");
                        dict.Add("Statistics_和值", "和值统计");
                    }
                    break;
                case eCronType.EachWeek:
                    {
                        dict.Add("Statistics_最大值", "最大值统计");
                        dict.Add("Statistics_最小值", "最小值统计");
                        dict.Add("Statistics_均值", "均值统计");
                        dict.Add("Statistics_差值", "差值统计");
                        dict.Add("Statistics_和值", "和值统计");
                    }
                    break;
                case eCronType.EachMonth:
                    {
                        dict.Add("Statistics_最大值", "最大值统计");
                        dict.Add("Statistics_最小值", "最小值统计");
                        dict.Add("Statistics_均值", "均值统计");
                        dict.Add("Statistics_差值", "差值统计");
                        dict.Add("Statistics_和值", "和值统计");
                    }
                    break;
                case eCronType.EachYear:
                    {
                        dict.Add("Statistics_最大值", "最大值统计");
                        dict.Add("Statistics_最小值", "最小值统计");
                        dict.Add("Statistics_均值", "均值统计");
                        dict.Add("Statistics_差值", "差值统计");
                        dict.Add("Statistics_和值", "和值统计");
                    }
                    break;
                default: break;
            }
            return dict;
        }

        /// <summary>
        /// 通过计划类型获取
        /// </summary>
        public static List<string> GetByCronType(eCronType cronType)
        {
            var list = new List<string>();
            switch (cronType)
            {
                case eCronType.Real:
                    {
                        list.Add("Calculation_单一映射");
                        list.Add("Calculation_比较映射");
                        list.Add("Calculation_区间映射");
                        list.Add("Calculation_一元系数");
                        list.Add("Calculation_二元系数");
                        list.Add("Calculation_自定义运行状态");
                        list.Add("Calculation_和值");
                        list.Add("Calculation_差值");
                        list.Add("Calculation_数值累积");
                        list.Add("Calculation_枚举累积");
                        list.Add("Calculation_效率");
                        list.Add("Calculation_千吨能耗");
                        list.Add("Calculation_单位能耗");
                        list.Add("Calculation_常量");
                    }
                    break;
                case eCronType.EachHour:
                    {
                        list.Add("Statistics_最大值");
                        list.Add("Statistics_最小值");
                        list.Add("Statistics_均值");
                        list.Add("Statistics_差值");
                        list.Add("Statistics_和值");
                    }
                    break;
                case eCronType.EachDay:
                    {
                        list.Add("Statistics_最大值");
                        list.Add("Statistics_最小值");
                        list.Add("Statistics_均值");
                        list.Add("Statistics_差值");
                        list.Add("Statistics_和值");
                    }
                    break;
                case eCronType.EachWeek:
                    {
                        list.Add("Statistics_最大值");
                        list.Add("Statistics_最小值");
                        list.Add("Statistics_均值");
                        list.Add("Statistics_差值");
                        list.Add("Statistics_和值");
                    }
                    break;
                case eCronType.EachMonth:
                    {
                        list.Add("Statistics_最大值");
                        list.Add("Statistics_最小值");
                        list.Add("Statistics_均值");
                        list.Add("Statistics_差值");
                        list.Add("Statistics_和值");
                    }
                    break;
                case eCronType.EachYear:
                    {
                        list.Add("Statistics_最大值");
                        list.Add("Statistics_最小值");
                        list.Add("Statistics_均值");
                        list.Add("Statistics_差值");
                        list.Add("Statistics_和值");
                    }
                    break;
                default: break;
            }
            return list;

        }


    }
}