namespace Yw.WinFrmUI.Phart
{
    /// <summary>
    ///  
    /// </summary>
    public partial class ValveCoordinate
    {
        #region 计算显示参数方法

        #region 默认
        /// <summary>
        /// 最大流量(显示参数)
        /// </summary> 
        public double DispMaxQ()
        {
            return this.CoordMinQ + (double)this.GridNumberX * this.CoordSpaceQ;
        }

        /// <summary>
        /// 最小水损(显示参数)
        /// </summary> 
        public double DispMinL()
        {
            return this.CoordMinL + (double)this.StartLineNoL * this.CoordSpaceL;
        }

        /// <summary>
        /// 最大水损(显示参数)
        /// </summary> 
        public double DispMaxL()
        {
            return CoordMinL + (double)this.EndLineNoL * this.CoordSpaceL;
        }


        #endregion

        /// <summary>
        /// 重置水损坐标
        /// </summary> 
        public void ResetCoordL(double space, double disMinL, double disMaxL)
        {
            this.CoordSpaceL = space;
            this.EndLineNoL = this.GridNumberY;
            this.StartLineNoL = this.EndLineNoL - (int)((disMaxL - disMinL) / this.CoordSpaceL);
            this.CoordMinL = disMaxL - (double)this.EndLineNoL * this.CoordSpaceL;
        }
        #endregion

        #region 计算坐标

        /// <summary>
        /// 计算坐标
        /// </summary>
        /// <param name="QL">流量水损线</param> 
        /// <returns></returns>
        public static ValveCoordinate CalcCoordinate(List<Yw.Geometry.Point2d> QL)
        {
            if (QL == null)
                return null;
            double max_flow = 0.0;
            double min_flow = 1000.0;
            double maxL = 0.0;
            double minL = 1000.0;


            min_flow = QL.Min(x => x.X);
            max_flow = QL.Max(x => x.X);
            if (min_flow > max_flow)
            {
                return null;
            }
            minL = QL.Min(x => x.Y);
            maxL = QL.Max(x => x.Y);
            if (minL > maxL)
            {
                return null;
            }


            return CalcCoordinate(min_flow, max_flow, minL, maxL);
        }

        /// <summary>
        /// 计算最大最小值
        /// </summary>
        /// <param name="QL">流量水损线</param> 
        /// <param name="max_flow">最大流量</param>
        /// <param name="min_flow">最小流量</param>
        /// <param name="maxL">最大水损</param>
        /// <param name="minL">最小水损</param> 
        /// <returns></returns>
        public static bool CalcMinMaxValue(List<Yw.Geometry.Point2d> QL, ref double max_flow, ref double min_flow, ref double maxL, ref double minL)
        {
            max_flow = 0.0;
            min_flow = 1000.0;
            maxL = 0.0;
            minL = 1000.0;
            if (QL == null)
            {
                return false;
            }
            min_flow = QL.Min(x => x.X);
            max_flow = QL.Max(x => x.X);
            if (min_flow > max_flow)
            {
                return false;
            }
            minL = QL.Min(x => x.Y);
            maxL = QL.Max(x => x.Y);
            return true;
        }

        /// <summary>
        /// 计算坐标
        /// </summary>
        /// <param name="min_flow">最小流量</param>
        /// <param name="max_flow">最大流量</param>
        /// <param name="minL">最小水损</param>
        /// <param name="maxL">最大水损</param> 
        /// <returns></returns>
        public static ValveCoordinate CalcCoordinate(double min_flow, double max_flow, double minL, double maxL)
        {
            if (min_flow > max_flow - 0.01)
                return null;

            if (minL > maxL - 0.01)
                return null;

            var validGridNumL = 6;
            var coordinate_paras = new ValveCoordinate();
            coordinate_paras.GridNumberX = 10;
            coordinate_paras.GridNumberY = 10;
            CalcCoordinateQ(min_flow, max_flow, ref coordinate_paras, coordinate_paras.GridNumberX);
            CalcCoordinateL(minL, maxL, validGridNumL, ref coordinate_paras, out double disMinL, out double disMaxL);

            return coordinate_paras;
        }

        #endregion

        #region 计算对应线坐标

        /// <summary>
        /// 计算流量坐标
        /// </summary>
        /// <param name="min_flow">最小流量</param>
        /// <param name="max_flow">最大流量</param>
        /// <param name="coordinate_paras">坐标Model</param>
        /// <param name="validGridNum">有效刻度点</param>
        /// <param name="default_num">放大系数</param>
        public static void CalcCoordinateQ(double min_flow, double max_flow, ref ValveCoordinate coordinate_paras, int validGridNum = 10, double default_num = 1.0)
        {
            var coordSpaceQ = GetOptimalSpaceMin(min_flow / default_num, max_flow / default_num, validGridNum, out double disMinQ, out double disMaxQ) * default_num;
            coordSpaceQ = Math.Max(0.5, coordSpaceQ / default_num) * default_num;
            if (coordSpaceQ == 8.0)
                coordSpaceQ = 10.0;

            disMinQ *= default_num;
            //disMaxQ *= default_num;
            var gridNumberX = 0;

            double min_q = disMinQ;
            while (min_q < max_flow)
            {
                gridNumberX++;
                min_q = disMinQ + gridNumberX * coordSpaceQ;
            }

            if (gridNumberX <= 5)
            {
                coordSpaceQ *= 0.5;
                gridNumberX *= 2;
            }

            coordinate_paras.CoordSpaceQ = coordSpaceQ;
            coordinate_paras.CoordMinQ = disMinQ;
            coordinate_paras.GridNumberX = gridNumberX;
        }

        /// <summary>
        /// 计算水损坐标 含过滤 (Eventech: CalcCoordinateL2) 
        /// </summary>
        /// <param name="minL">最小水损</param>
        /// <param name="maxL">最大水损</param>
        /// <param name="validGridNumL">有效水损刻度数</param>
        /// <param name="coordinate_paras">坐标Model</param>
        /// <param name="disMinL">最小显示水损</param>
        /// <param name="disMaxL">最大显示水损</param>
        public static void CalcCoordinateL_Filter(double minL, double maxL, int validGridNumL, ref ValveCoordinate coordinate_paras, out double disMinL, out double disMaxL)
        {
            if (maxL < 1.0)
            {
                disMinL = 0.0;
                disMaxL = 1.0;
                coordinate_paras.ResetCoordL(0.1, disMinL, disMaxL);
            }
            else if (maxL < 2.0)
            {
                disMinL = 0.0;
                disMaxL = 2.0;
                coordinate_paras.ResetCoordL(0.2, disMinL, disMaxL);
            }
            else if (maxL < 5.0)
            {
                disMinL = 0.0;
                disMaxL = 5.0;
                coordinate_paras.ResetCoordL(0.5, disMinL, disMaxL);
            }
            else if (maxL < 10.0)
            {
                disMinL = 0.0;
                disMaxL = 10.0;
                coordinate_paras.ResetCoordL(1.0, disMinL, disMaxL);
            }
            else if (maxL < 12.0)
            {
                coordinate_paras.CoordSpaceL = 1.0;
                disMinL = 0.0;
                disMaxL = 12.0;
                coordinate_paras.ResetCoordL(1.0, disMinL, disMaxL);
            }
            else if (maxL < 15.0)
            {
                coordinate_paras.CoordSpaceL = 2.0;
                disMinL = 0.0;
                disMaxL = 16.0;
                coordinate_paras.ResetCoordL(2.0, disMinL, disMaxL);
            }
            else if (maxL < 20.0)
            {
                coordinate_paras.CoordSpaceL = 2.0;
                disMinL = 0.0;
                disMaxL = 20.0;
                coordinate_paras.ResetCoordL(2.0, disMinL, disMaxL);
            }
            else
            {
                CalcCoordinateL(minL, maxL, validGridNumL, ref coordinate_paras, out disMinL, out disMaxL);
            }
        }

        /// <summary>
        /// 计算水损坐标
        /// </summary>
        /// <param name="minL">最小水损</param>
        /// <param name="maxL">最大水损</param>
        /// <param name="validGridNumL">有效水损刻度数</param>
        /// <param name="coordinate_paras">坐标Model</param>
        /// <param name="disMinL">最小显示水损</param>
        /// <param name="disMaxL">最大显示水损</param>
        public static void CalcCoordinateL(double minL, double maxL, int validGridNumL, ref ValveCoordinate coordinate_paras, out double disMinL, out double disMaxL)
        {
            var coordSpaceL = GetOptimalSpaceMax(minL, maxL, validGridNumL, out disMinL, out disMaxL);
            int endLineNoL = coordinate_paras.GridNumberY;
            int stratLineNoL = endLineNoL;

            double max_h = disMaxL;//判断条件
            while (max_h > minL * 0.98)
            {
                max_h -= coordSpaceL;
                if (max_h < 0.0)
                    break;
                stratLineNoL--;
            }

            coordinate_paras.CoordSpaceL = coordSpaceL;
            coordinate_paras.EndLineNoL = endLineNoL;
            coordinate_paras.StartLineNoL = stratLineNoL;
            coordinate_paras.CoordMinL = disMaxL - (double)endLineNoL * coordSpaceL;
        }

        #endregion

        #region Space 间隔 
        /// <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) / (double)spaceNum);
            if (optimalSpace < 2.0)
            {
                minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
                maxDisplay = minDisplay + (double)spaceNum * optimalSpace;
            }
            else
            {
                minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
                maxDisplay = minDisplay + (double)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) / (double)spaceNum, true);
            maxDisplay = Math.Ceiling(maxValue / optimalSpace) * optimalSpace;
            minDisplay = maxDisplay - (double)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.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;
        }

        #endregion

        #region 数字辅助方法
        /// <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;
        }
        #endregion

    }
}