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

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

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

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

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

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

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

        /// <summary>
        /// 最大功率(显示参数)
        /// </summary> 
        public double DispMaxP()
        {
            return this.CoordMinP + 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 - this.EndLineNoH * this.CoordSpaceH;
        }
        #endregion

        #region 计算坐标

        /// <summary>
        /// 计算坐标
        /// </summary>
        /// <param name="QH">流量扬程线</param>
        /// <param name="QE">流量效率线</param>
        /// <param name="QP">流量功率线</param>
        /// <returns></returns>
        public static PumpCoordinate CalcCoordinate(List<Yw.Geometry.Point2d> QH, List<Yw.Geometry.Point2d> QE, List<Yw.Geometry.Point2d> QP)
        {
            if (QH == null)
                return null;
            double max_flow = 0.0;
            double min_flow = 1000.0;
            double max_head = 0.0;
            double min_head = 1000.0;
            double max_eff = 0.0;
            double min_eff = 1000.0;
            double max_power = 0.0;
            double min_power = 1000.0;

            if (QE == null && QP == null)
            {
                min_flow = QH.Min(x => x.X);
                max_flow = QH.Max(x => x.X);
                if (min_flow > max_flow)
                {
                    return null;
                }
                min_head = QH.Min(x => x.Y);
                max_head = QH.Max(x => x.Y);
                if (min_head > max_head)
                {
                    return null;
                }
            }
            else
            {
                CalcMinMaxValue(QH, QE, QP, ref max_flow, ref min_flow, ref max_head, ref min_head, ref max_eff, ref min_eff, ref max_power, ref min_power);
            }

            var calc_corrd = CalcCoordinate(min_flow, max_flow, min_head, max_head, min_eff, max_eff, min_power, max_power);

            #region 修正Y轴

            var head_num_y = calc_corrd.EndLineNoH - calc_corrd.StartLineNoH;
            var eff_num_y = calc_corrd.EndLineNoE - calc_corrd.StartLineNoE;
            var power_num_y = calc_corrd.EndLineNoP - calc_corrd.StartLineNoP;
            var sun_num_y = Math.Abs(head_num_y + eff_num_y + power_num_y);
            if (sun_num_y < calc_corrd.GridNumberY)
            {
                calc_corrd.StartLineNoP = 1;
            }
            #endregion

            return calc_corrd;
        }

        /// <summary>
        /// 计算最大最小值
        /// </summary>
        /// <param name="QH">流量扬程线</param>
        /// <param name="QE">流量效率线</param>
        /// <param name="QP">流量功率线</param>
        /// <param name="max_flow">最大流量</param>
        /// <param name="min_flow">最小流量</param>
        /// <param name="max_head">最大扬程</param>
        /// <param name="min_head">最小扬程</param>
        /// <param name="max_eff">最大效率</param>
        /// <param name="min_eff">最小效率</param>
        /// <param name="max_power">最大功率</param>
        /// <param name="min_power">最小功率</param>
        /// <returns></returns>
        public static bool CalcMinMaxValue(List<Yw.Geometry.Point2d> QH, List<Yw.Geometry.Point2d> QE, List<Yw.Geometry.Point2d> QP, ref double max_flow, ref double min_flow, ref double max_head, ref double min_head, ref double max_eff, ref double min_eff, ref double max_power, ref double min_power)
        {
            max_flow = 0.0;
            min_flow = 1000.0;
            max_head = 0.0;
            min_head = 1000.0;
            max_eff = 0.0;
            min_eff = 1000.0;
            max_power = 0.0;
            min_power = 1000.0;
            if (QH == null)
            {
                return false;
            }
            min_flow = QH.Min(x => x.X);
            max_flow = QH.Max(x => x.X);
            if (min_flow > max_flow)
            {
                return false;
            }
            min_head = QH.Min(x => x.Y);
            max_head = QH.Max(x => x.Y);
            if (QE != null && QE.Count > 0)
            {
                min_eff = QE.Min(x => x.Y);
                max_eff = QE.Max(x => x.Y);
            }
            if (QP != null && QP.Count > 0)
            {
                min_power = QP.Min(x => x.Y);
                max_power = QP.Max(x => x.Y);
            }
            return true;
        }

        /// <summary>
        /// 计算坐标
        /// </summary>
        /// <param name="min_flow">最小流量</param>
        /// <param name="max_flow">最大流量</param>
        /// <param name="min_head">最小扬程</param>
        /// <param name="max_head">最大扬程</param>
        /// <param name="min_eff">最小效率</param>
        /// <param name="max_eff">最大效率</param>
        /// <param name="min_power">最小功率</param>
        /// <param name="max_power">最大功率</param>
        /// <returns></returns>
        public static PumpCoordinate CalcCoordinate(double min_flow, double max_flow, double min_head, double max_head, double min_eff, double max_eff, double min_power, double max_power)
        {
            if (min_flow > max_flow - 0.01)
                return null;

            if (min_head > max_head - 0.01)
                return null;

            var validGridNumH = 6;
            var coordinate_paras = new PumpCoordinate();
            coordinate_paras.GridNumberX = 10;//10
            coordinate_paras.GridNumberY = 18;//18
            CalcCoordinateQ(min_flow, max_flow, ref coordinate_paras, coordinate_paras.GridNumberX);
            CalcCoordinateH(min_head, max_head, validGridNumH, ref coordinate_paras, out double disMinH, out double disMaxH);

            if (max_power > min_power + 0.01)
                CalcCoordinateP(min_power, max_power, disMaxH, 0, ref coordinate_paras);

            if (max_eff > min_eff + 0.01)
                CalcCoordinateE(min_eff, max_eff, ref coordinate_paras);

            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 PumpCoordinate 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: CalcCoordinateH2) 
        /// </summary>
        /// <param name="min_head">最小扬程</param>
        /// <param name="max_head">最大扬程</param>
        /// <param name="validGridNumH">有效扬程刻度数</param>
        /// <param name="coordinate_paras">坐标Model</param>
        /// <param name="disMinH">最小显示扬程</param>
        /// <param name="disMaxH">最大显示扬程</param>
        public static void CalcCoordinateH_Filter(double min_head, double max_head, int validGridNumH, ref PumpCoordinate coordinate_paras, out double disMinH, out double disMaxH)
        {
            if (max_head < 1.0)
            {
                disMinH = 0.0;
                disMaxH = 1.0;
                coordinate_paras.ResetCoordH(0.1, disMinH, disMaxH);
            }
            else if (max_head < 2.0)
            {
                disMinH = 0.0;
                disMaxH = 2.0;
                coordinate_paras.ResetCoordH(0.2, disMinH, disMaxH);
            }
            else if (max_head < 5.0)
            {
                disMinH = 0.0;
                disMaxH = 5.0;
                coordinate_paras.ResetCoordH(0.5, disMinH, disMaxH);
            }
            else if (max_head < 10.0)
            {
                disMinH = 0.0;
                disMaxH = 10.0;
                coordinate_paras.ResetCoordH(1.0, disMinH, disMaxH);
            }
            else if (max_head < 12.0)
            {
                coordinate_paras.CoordSpaceH = 1.0;
                disMinH = 0.0;
                disMaxH = 12.0;
                coordinate_paras.ResetCoordH(1.0, disMinH, disMaxH);
            }
            else if (max_head < 15.0)
            {
                coordinate_paras.CoordSpaceH = 2.0;
                disMinH = 0.0;
                disMaxH = 16.0;
                coordinate_paras.ResetCoordH(2.0, disMinH, disMaxH);
            }
            else if (max_head < 20.0)
            {
                coordinate_paras.CoordSpaceH = 2.0;
                disMinH = 0.0;
                disMaxH = 20.0;
                coordinate_paras.ResetCoordH(2.0, disMinH, disMaxH);
            }
            else
            {
                CalcCoordinateH(min_head, max_head, validGridNumH, ref coordinate_paras, out disMinH, out disMaxH);
            }
        }

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

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

            coordinate_paras.CoordSpaceH = coordSpaceH;
            coordinate_paras.EndLineNoH = endLineNoH;
            coordinate_paras.StartLineNoH = stratLineNoH;
            coordinate_paras.CoordMinH = disMaxH - endLineNoH * coordSpaceH;
        }

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

            var coordSpaceP = GetOptimalSpaceMax(min_power, max_power, spaceNum, out double disMinP, out double disMaxP);
            int endLineNoP = coordinate_paras.StartLineNoH - default_num;
            int stratLineNoP = endLineNoP;

            double max_p = disMaxP;
            //while (max_p > min_power * 0.98)
            while (max_p > min_power)
            {
                max_p -= coordSpaceP;
                if (max_p < 0.0)
                    break;
                stratLineNoP--;
            }
             
            coordinate_paras.CoordSpaceP = coordSpaceP;
            coordinate_paras.EndLineNoP = endLineNoP;
            coordinate_paras.StartLineNoP = stratLineNoP;

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


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

        /// <summary>
        /// 计算效率坐标
        /// </summary>
        /// <param name="min_eff">最小效率</param>
        /// <param name="max_eff">最大效率</param>
        /// <param name="coordinate_paras">坐标Model</param>
        public static void CalcCoordinateE(double min_eff, double max_eff, ref PumpCoordinate coordinate_paras)
        {
            int startLineNoE = coordinate_paras.StartLineNoH - 6;
            if (max_eff <= 40.0)
            {
                coordinate_paras.StartLineNoE = startLineNoE;
                coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 6;
                coordinate_paras.CoordSpaceE = 5.0;
            }
            else if (max_eff <= 50.0)
            {
                coordinate_paras.StartLineNoE = startLineNoE - 5;
                coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 10;
                coordinate_paras.CoordSpaceE = 5.0;
            }
            else if (max_eff <= 60)
            {
                coordinate_paras.StartLineNoE = startLineNoE;
                coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 6;
                coordinate_paras.CoordSpaceE = 10.0;
            }
            else
            { 
                coordinate_paras.StartLineNoE = startLineNoE  ;
                coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 5;
                coordinate_paras.CoordSpaceE = 20.0;
            }
            coordinate_paras.CoordMinE = (-coordinate_paras.StartLineNoE) * coordinate_paras.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) / spaceNum);
            if (optimalSpace < 2.0)
            {
                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.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

    }
}