namespace IStation.Curve
{
    /// <summary>
    ///  
    /// </summary>
    public partial class CurveCoordinate
    {
        #region 计算显示参数方法

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

        /// <summary>
        /// 最小扬程(显示参数)
        /// </summary> 
        public double DispMinH()
        {
            return this.CoordMinH + (double)this.StartLineNoH * this.CoordSpaceH;
        }

        /// <summary>
        /// 最大扬程(显示参数)
        /// </summary> 
        public double DispMaxH()
        {
            return CoordMinH + (double)this.EndLineNoH * this.CoordSpaceH;
        }

        /// <summary>
        /// 最小效率(显示参数)
        /// </summary> 
        public double DispMinE()
        {
            return this.CoordMinE + (double)this.StartLineNoE * this.CoordSpaceE;
        }

        /// <summary>
        /// 最大效率(显示参数)
        /// </summary> 
        public double DispMaxE()
        {
            return this.CoordMinE + (double)this.EndLineNoE * this.CoordSpaceE;
        }

        /// <summary>
        /// 最小功率(显示参数)
        /// </summary> 
        public double DispMinP()
        {
            return this.CoordMinP + (double)this.StartLineNoP * this.CoordSpaceP;
        }

        /// <summary>
        /// 最大功率(显示参数)
        /// </summary> 
        public double DispMaxP()
        {
            return this.CoordMinP + (double)this.EndLineNoP * this.CoordSpaceP;
        }

        #endregion

        /// <summary>
        /// 重置扬程坐标
        /// </summary> 
        public void ResetCoordH(double space, double disMinH, double disMaxH)
        {
            this.CoordSpaceH = space;
            this.EndLineNoH = this.GridNumberY;
            this.StartLineNoH = this.EndLineNoH - (int)((disMaxH - disMinH) / this.CoordSpaceH);
            this.CoordMinH = disMaxH - (double)this.EndLineNoH * this.CoordSpaceH;
        }
        #endregion

        #region 计算坐标

        /// <summary>
        /// 计算坐标
        /// </summary>
        /// <param name="QH">流量扬程线</param>
        /// <param name="QE">流量效率线</param>
        /// <param name="QP">流量功率线</param>
        /// <returns></returns>
        public static CurveCoordinate CalcCoordinate(CurveExpress QH, CurveExpress QE, CurveExpress QP)
        {
            if (QH == null)
                return null;

            List<CurvePoint> pointsQH = QH.GetFitPoints(20);
            List<CurvePoint> pointsQE = null;
            if (QE != null)
                pointsQE = QE.GetFitPoints(20);
            List<CurvePoint> pointsQP = null;
            if (QP != null)
                pointsQP = QP.GetFitPoints(20);

            return CalcCoordinate(pointsQH, pointsQE, pointsQP);
        }

        /// <summary>
        /// 计算坐标
        /// </summary>
        /// <param name="QH">流量扬程线</param>
        /// <param name="QE">流量效率线</param>
        /// <param name="QP">流量功率线</param>
        /// <returns></returns>
        public static CurveCoordinate CalcCoordinate(List<CurvePoint> QH, List<CurvePoint> QE, List<CurvePoint> QP)
        {
            if (QH == null)
                return null;
            double maxQ = 0.0;
            double minQ = 1000.0;
            double maxH = 0.0;
            double minH = 1000.0;
            double maxE = 0.0;
            double minE = 1000.0;
            double maxP = 0.0;
            double minP = 1000.0;

            if (QE == null && QP == null)
            {
                minQ = QH.Min(x => x.X);
                maxQ = QH.Max(x => x.X);
                if (minQ > maxQ)
                {
                    return null;
                }
                minH = QH.Min(x => x.Y);
                maxH = QH.Max(x => x.Y);
                if (minH > maxH)
                {
                    return null;
                }
            }
            else
            {
                CalcMinMaxValue(QH, QE, QP, ref maxQ, ref minQ, ref maxH, ref minH, ref maxE, ref minE, ref maxP, ref minP);
            }

            return CalcCoordinate(minQ, maxQ, minH, maxH, minE, maxE, minP, maxP);
        }

        /// <summary>
        /// 计算最大最小值
        /// </summary>
        /// <param name="QH">流量扬程线</param>
        /// <param name="QE">流量效率线</param>
        /// <param name="QP">流量功率线</param>
        /// <param name="maxQ">最大流量</param>
        /// <param name="minQ">最小流量</param>
        /// <param name="maxH">最大扬程</param>
        /// <param name="minH">最小扬程</param>
        /// <param name="maxE">最大效率</param>
        /// <param name="minE">最小效率</param>
        /// <param name="maxP">最大功率</param>
        /// <param name="minP">最小功率</param>
        /// <returns></returns>
        public static bool CalcMinMaxValue(List<CurvePoint> QH, List<CurvePoint> QE, List<CurvePoint> QP, ref double maxQ, ref double minQ, ref double maxH, ref double minH, ref double maxE, ref double minE, ref double maxP, ref double minP)
        {
            maxQ = 0.0;
            minQ = 1000.0;
            maxH = 0.0;
            minH = 1000.0;
            maxE = 0.0;
            minE = 1000.0;
            maxP = 0.0;
            minP = 1000.0;
            if (QH == null)
            {
                return false;
            }
            minQ = QH.Min(x => x.X);
            maxQ = QH.Max(x => x.X);
            if (minQ > maxQ)
            {
                return false;
            }
            minH = QH.Min(x => x.Y);
            maxH = QH.Max(x => x.Y);
            if (QE != null && QE.Count > 0)
            {
                minE = QE.Min(x => x.Y);
                maxE = QE.Max(x => x.Y);
            }
            if (QP != null && QP.Count > 0)
            {
                minP = QP.Min(x => x.Y);
                maxP = QP.Max(x => x.Y);
            }
            return true;
        }

        /// <summary>
        /// 计算坐标
        /// </summary>
        /// <param name="minQ">最小流量</param>
        /// <param name="maxQ">最大流量</param>
        /// <param name="minH">最小扬程</param>
        /// <param name="maxH">最大扬程</param>
        /// <param name="minE">最小效率</param>
        /// <param name="maxE">最大效率</param>
        /// <param name="minP">最小功率</param>
        /// <param name="maxP">最大功率</param>
        /// <returns></returns>
        public static CurveCoordinate CalcCoordinate(double minQ, double maxQ, double minH, double maxH, double minE, double maxE, double minP, double maxP)
        {
            if (minQ > maxQ - 0.01)
                return null;

            if (minH > maxH - 0.01)
                return null;

            var validGridNumH = 6;
            var coordinateParas = new CurveCoordinate();
            coordinateParas.GridNumberX = 10;
            coordinateParas.GridNumberY = 18;
            CalcCoordinateQ(minQ, maxQ, ref coordinateParas, coordinateParas.GridNumberX);
            CalcCoordinateH(minH, maxH, validGridNumH, ref coordinateParas, out double disMinH, out double disMaxH);

            if (maxP > minP + 0.01)
                CalcCoordinateP(minP, maxP, disMaxH, 0, ref coordinateParas);

            if (maxE > minE + 0.01)
                CalcCoordinateE(minE, maxE, ref coordinateParas);

            return coordinateParas;
        }

        #endregion

        #region 计算对应线坐标

        /// <summary>
        /// 计算流量坐标
        /// </summary>
        /// <param name="minQ">最小流量</param>
        /// <param name="maxQ">最大流量</param>
        /// <param name="coordinateParas">坐标Model</param>
        /// <param name="validGridNum">有效刻度点</param>
        /// <param name="default_num">放大系数</param>
        public static void CalcCoordinateQ(double minQ, double maxQ, ref CurveCoordinate coordinateParas, int validGridNum = 10, double default_num = 1.0)
        {
            var coordSpaceQ = GetOptimalSpaceMin(minQ / default_num, maxQ / 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 < maxQ)
            {
                gridNumberX++;
                min_q = disMinQ + gridNumberX * coordSpaceQ;
            }

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

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

        /// <summary>
        /// 计算扬程坐标 含过滤 (Eventech: CalcCoordinateH2) 
        /// </summary>
        /// <param name="minH">最小扬程</param>
        /// <param name="maxH">最大扬程</param>
        /// <param name="validGridNumH">有效扬程刻度数</param>
        /// <param name="coordinateParas">坐标Model</param>
        /// <param name="disMinH">最小显示扬程</param>
        /// <param name="disMaxH">最大显示扬程</param>
        public static void CalcCoordinateH_Filter(double minH, double maxH, int validGridNumH, ref CurveCoordinate coordinateParas, out double disMinH, out double disMaxH)
        {
            if (maxH < 1.0)
            {
                disMinH = 0.0;
                disMaxH = 1.0;
                coordinateParas.ResetCoordH(0.1, disMinH, disMaxH);
            }
            else if (maxH < 2.0)
            {
                disMinH = 0.0;
                disMaxH = 2.0;
                coordinateParas.ResetCoordH(0.2, disMinH, disMaxH);
            }
            else if (maxH < 5.0)
            {
                disMinH = 0.0;
                disMaxH = 5.0;
                coordinateParas.ResetCoordH(0.5, disMinH, disMaxH);
            }
            else if (maxH < 10.0)
            {
                disMinH = 0.0;
                disMaxH = 10.0;
                coordinateParas.ResetCoordH(1.0, disMinH, disMaxH);
            }
            else if (maxH < 12.0)
            {
                coordinateParas.CoordSpaceH = 1.0;
                disMinH = 0.0;
                disMaxH = 12.0;
                coordinateParas.ResetCoordH(1.0, disMinH, disMaxH);
            }
            else if (maxH < 15.0)
            {
                coordinateParas.CoordSpaceH = 2.0;
                disMinH = 0.0;
                disMaxH = 16.0;
                coordinateParas.ResetCoordH(2.0, disMinH, disMaxH);
            }
            else if (maxH < 20.0)
            {
                coordinateParas.CoordSpaceH = 2.0;
                disMinH = 0.0;
                disMaxH = 20.0;
                coordinateParas.ResetCoordH(2.0, disMinH, disMaxH);
            }
            else
            {
                CalcCoordinateH(minH, maxH, validGridNumH, ref coordinateParas, out disMinH, out disMaxH);
            }
        }

        /// <summary>
        /// 计算扬程坐标
        /// </summary>
        /// <param name="minH">最小扬程</param>
        /// <param name="maxH">最大扬程</param>
        /// <param name="validGridNumH">有效扬程刻度数</param>
        /// <param name="coordinateParas">坐标Model</param>
        /// <param name="disMinH">最小显示扬程</param>
        /// <param name="disMaxH">最大显示扬程</param>
        public static void CalcCoordinateH(double minH, double maxH, int validGridNumH, ref CurveCoordinate coordinateParas, out double disMinH, out double disMaxH)
        {
            var coordSpaceH = GetOptimalSpaceMax(minH, maxH, validGridNumH, out disMinH, out disMaxH);
            int endLineNoH = coordinateParas.GridNumberY;
            int stratLineNoH = endLineNoH;

            double max_h = disMaxH;//判断条件
            while (max_h > minH * 0.98)
            {
                max_h -= coordSpaceH;
                if (max_h < 0.0)
                    break;
                stratLineNoH--;
            }

            coordinateParas.CoordSpaceH = coordSpaceH;
            coordinateParas.EndLineNoH = endLineNoH;
            coordinateParas.StartLineNoH = stratLineNoH;
            coordinateParas.CoordMinH = disMaxH - (double)endLineNoH * coordSpaceH;
        }

        /// <summary>
        /// 计算功率坐标
        /// </summary>
        /// <param name="minP">最小功率</param>
        /// <param name="maxP">最大功率</param>
        /// <param name="disMaxH">最大显示扬程</param>
        /// <param name="downGridNum">最低点刻度</param>
        /// <param name="coordinateParas">坐标Model</param>
        public static void CalcCoordinateP(double minP, double maxP, double disMaxH, int downGridNum, ref CurveCoordinate coordinateParas)
        {
            int default_num = 5;
            int spaceNum = coordinateParas.StartLineNoH - default_num - downGridNum;
            if (spaceNum < 3)
                spaceNum = 3;

            var coordSpaceP = GetOptimalSpaceMax(minP, maxP, spaceNum, out double disMinP, out double disMaxP);
            int endLineNoP = coordinateParas.StartLineNoH - default_num;
            int stratLineNoP = endLineNoP;

            double max_p = disMaxP;
            while (max_p > minP * 0.98)
            {
                max_p -= coordSpaceP;
                if (max_p < 0.0)
                    break;
                stratLineNoP--;
            }

            coordinateParas.CoordSpaceP = coordSpaceP;
            coordinateParas.EndLineNoP = endLineNoP;
            coordinateParas.StartLineNoP = stratLineNoP;

            //如果开始刻度低于最低点刻度 都往上加差值
            if (coordinateParas.StartLineNoP < downGridNum)
            {
                int diff_num = downGridNum - coordinateParas.StartLineNoP;

                coordinateParas.EndLineNoP += diff_num;
                coordinateParas.StartLineNoP += diff_num;
            }

            coordinateParas.CoordMinH = GetByPlacesLength(disMaxH - (double)coordinateParas.EndLineNoH * coordinateParas.CoordSpaceH, 3);
            coordinateParas.CoordMinP = GetByPlacesLength(disMaxP - (double)coordinateParas.EndLineNoP * coordinateParas.CoordSpaceP, 3);
        }

        /// <summary>
        /// 计算效率坐标
        /// </summary>
        /// <param name="minE">最小效率</param>
        /// <param name="maxE">最大效率</param>
        /// <param name="coordinateParas">坐标Model</param>
        public static void CalcCoordinateE(double minE, double maxE, ref CurveCoordinate coordinateParas)
        {
            int startLineNoE = coordinateParas.StartLineNoH - 6;
            if (maxE <= 40.0)
            {
                coordinateParas.StartLineNoE = startLineNoE;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 6;
                coordinateParas.CoordSpaceE = 5.0;
            }
            else if (maxE <= 50.0)
            {
                coordinateParas.StartLineNoE = startLineNoE - 5;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 10;
                coordinateParas.CoordSpaceE = 5.0;
            }
            else if (maxE <= 60)
            {
                coordinateParas.StartLineNoE = startLineNoE;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 6;
                coordinateParas.CoordSpaceE = 10.0;
            }
            else
            {
                coordinateParas.StartLineNoE = startLineNoE;
                coordinateParas.EndLineNoE = coordinateParas.StartLineNoE + 5;
                coordinateParas.CoordSpaceE = 20.0;
            }
            coordinateParas.CoordMinE = (double)(-coordinateParas.StartLineNoE) * coordinateParas.CoordSpaceE;
        }

        #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

    }
}