namespace Yw.WinFrmUI
{
    /// <summary>
    /// 坐标辅助类
    /// </summary>
    public class PhartCoordinateHelper
    {
        /// <summary>
        /// 获取最小的间隔
        /// </summary>
        /// <param name="minValue">最小值</param>
        /// <param name="maxValue">最大值</param>
        /// <param name="spaceNum">间隔数量</param>
        /// <param name="minDisplay">最小显示参数</param>
        /// <param name="maxDisplay">最大显示参数</param>
        /// <returns></returns>
        public static double GetOptimalSpaceMin(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
        {
            minDisplay = minValue;
            maxDisplay = maxValue;
            double num = maxValue - minValue;
            if (num < 0.0 || spaceNum < 1)
            {
                return (maxValue - minValue) / 10.0;
            }

            double optimalSpace = GetOptimalSpace((maxValue - minValue) / spaceNum);
            if (optimalSpace < 2)
            {
                minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
                maxDisplay = minDisplay + spaceNum * optimalSpace;
            }
            else
            {
                minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
                maxDisplay = minDisplay + spaceNum * optimalSpace;
            }

            return optimalSpace;
        }

        /// <summary> 
        /// 获取最大的间隔
        /// </summary>
        /// <param name="minValue">最小值</param>
        /// <param name="maxValue">最大值</param>
        /// <param name="spaceNum">间隔数量</param>
        /// <param name="minDisplay">最小显示参数</param>
        /// <param name="maxDisplay">最大显示参数</param>
        /// <returns></returns>
        public static double GetOptimalSpaceMax(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
        {
            minDisplay = minValue;
            maxDisplay = maxValue;
            double num = maxValue - minValue;

            if (maxValue > 20)
            {
                if (num < 0.0 || spaceNum < 1)
                {
                    return (maxValue - minValue) / 5.0;
                }
            }
            else
            {
                if (num < 0.0 || spaceNum < 1)
                {
                    return (maxValue - minValue) / 10.0;
                }
            }

            double optimalSpace = GetOptimalSpace((maxValue - minValue) / spaceNum, true);
            maxDisplay = Math.Ceiling(maxValue / optimalSpace) * optimalSpace;
            minDisplay = maxDisplay - spaceNum * optimalSpace;

            if (minDisplay > minValue)
            {
                var diff = minDisplay - minValue;
                if (diff < optimalSpace)
                {
                    minDisplay -= optimalSpace;
                }

            }

            return optimalSpace;
        }

        /// <summary>
        /// 获取最佳间隔 (精细取整)
        /// </summary>
        /// <param name="refSpace"> 间隔</param>
        /// <returns></returns>
        public static double GetOptimalSpace(double refSpace, bool IsAccurate = false)
        {
            if (refSpace < 1E-06)
            {
                return 1.0;
            }

            if (refSpace < 0.01)
            {
                double refSpace2 = refSpace * 100.0;
                return GetOptimalSpace(refSpace2) / 100.0;
            }

            if (refSpace < 0.1)
            {
                double refSpace3 = refSpace * 10.0;
                return GetOptimalSpace(refSpace3) / 10.0;
            }

            if (IsAccurate)
            {
                if (refSpace < 11.0)
                {
                    if (refSpace < 1)
                    {
                        return 0.5;
                    }
                    if (refSpace < 1.35)
                    {
                        return 1.0;
                    }

                    if (refSpace < 2.2)
                    {
                        return 2.0;
                    }

                    if (refSpace < 5.5)
                    {
                        return 5.0;
                    }

                    if (refSpace < 8.5)
                    {
                        return 8.0;
                    }

                    return 10.0;
                }
            }

            if (refSpace < 1.0)
            {
                if (refSpace < 0.15)
                {
                    return 0.1;
                }

                if (refSpace < 0.22)
                {
                    return 0.2;
                }

                if (refSpace < 0.6)
                {
                    return 0.5;
                }

                return 1.0;
            }

            if (refSpace < 1.2)
            {
                return 1.0;
            }

            if (refSpace < 3.0)
            {
                if (refSpace < 1.2)
                {
                    return 1.0;
                }

                if (refSpace < 2.3)
                {
                    return 2.0;
                }

                return 3.0;
            }

            if (refSpace < 11.0)
            {
                if (refSpace < 1.35)
                {
                    return 1.0;
                }

                if (refSpace < 2.2)
                {
                    return 2.0;
                }

                if (refSpace < 5.5)
                {
                    return 5.0;
                }

                if (refSpace < 8.5)
                {
                    return 8.0;
                }

                return 10.0;
            }

            if (refSpace < 16.0)
            {
                return 15.0;
            }

            if (refSpace < 22.0)
            {
                return 20.0;
            }

            if (refSpace < 35.0)
            {
                return 25.0;
            }

            if (refSpace < 41.0)
            {
                return 40.0;
            }

            if (refSpace < 51.0)
            {
                return 50.0;
            }

            if (refSpace < 61.0)
            {
                return 60.0;
            }

            if (refSpace < 71.0)
            {
                return 70.0;
            }

            if (refSpace < 78.0)
            {
                return 75.0;
            }

            if (refSpace < 150.0)
            {
                return 100.0;
            }

            if (refSpace < 230.0)
            {
                return 200.0;
            }

            if (refSpace < 270.0)
            {
                return 250.0;
            }

            if (refSpace < 1500.0)
            {
                int num = (int)(refSpace / 100.0);
                return num * 100;
            }

            int num2 = (int)(refSpace / 1000.0);
            return num2 * 1000;
        }



        /// <summary>
        /// 按指定长度获取
        /// </summary> 
        public static double GetByPlacesLength(double value, int length)
        {
            int decimalPlacesLength = GetDecimalPlacesLength(value);
            if (decimalPlacesLength > length)
            {
                return Math.Round(value, length);
            }
            return value;
        }

        /// <summary>
        /// 获取小数点长度
        /// </summary> 
        private static int GetDecimalPlacesLength(double value)
        {
            string text = value.ToString();
            int num = text.IndexOf('.');
            if (num >= 0)
            {
                return text.Length - num - 1;
            }
            return 0;
        }

    }


}