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 valid_grid_num_h = 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, valid_grid_num_h, 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 = PhartCoordinateHelper.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="valid_grid_num_h">有效扬程刻度数</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 valid_grid_num_h, 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, valid_grid_num_h, ref coordinate_paras, out disMinH, out disMaxH);
            }
        }

        /// <summary>
        /// 计算扬程坐标
        /// </summary>
        /// <param name="min_head">最小扬程</param>
        /// <param name="max_head">最大扬程</param>
        /// <param name="valid_grid_num_h">有效扬程刻度数</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 valid_grid_num_h, ref PumpCoordinate coordinate_paras, out double disMinH, out double disMaxH)
        {
            var coordSpaceH = PhartCoordinateHelper.GetOptimalSpaceMax(min_head, max_head, valid_grid_num_h, 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 = PhartCoordinateHelper.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)
            {
                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 = PhartCoordinateHelper.GetByPlacesLength(disMaxH - coordinate_paras.EndLineNoH * coordinate_paras.CoordSpaceH, 3);
            coordinate_paras.CoordMinP = PhartCoordinateHelper.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


    }
}