namespace IStation.Curve
{
    /// <summary>
    ///  串并联辅助类
    /// </summary>
    public class ParallelConnectionHelper
    {

        // 计算曲线列表
        private List<CurveExpress> _curveQhList = new List<CurveExpress>();
        private List<CurveExpress> _curveQpList = new List<CurveExpress>();

        // 延长率, 默认不延长
        private double _extendMinRatio = 1;
        private double _extendMaxRatio = 1;

        //求Q的最大最小值
        double minQ = 0, maxQ = 100000;

        //求H的最大最小值
        double minH = 0, maxH = 100000;

        #region Curve
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="curveQh"></param>
        /// <param name="curveQp"></param>
        public void AddCurve(CurveExpress curveQh, CurveExpress curveQp)
        {
            if (curveQh != null)
                _curveQhList.Add(curveQh);

            if (curveQp != null)
                _curveQpList.Add(curveQp);
        }

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="pointsQH"></param>
        /// <param name="pointsQP"></param>
        public void AddCurve(List<CurvePoint> pointsQH, List<CurvePoint> pointsQP)
        {
            if (pointsQH != null && pointsQH.Count > 3)
                _curveQhList.Add(FitHelper.BuildCurveExpress(pointsQH, eFitType.CubicCurve));
            if (pointsQP != null && pointsQP.Count > 3)
                _curveQpList.Add(FitHelper.BuildCurveExpress(pointsQH, eFitType.CubicCurve));
        }

        /// <summary>
        /// 清除
        /// </summary>
        public void ClearCurve()
        {
            this.minQ = 0;
            this.maxQ = 100000;
            this.minH = 0;
            this.maxH = 100000;
            _curveQhList.Clear();
            _curveQpList.Clear();
        }
        #endregion

        /// <summary>
        /// 计算并联
        /// </summary>
        /// <param name="pointQH"></param>
        /// <param name="pointQE"></param>
        /// <param name="pointQP"></param>
        /// <returns></returns>
        public bool CalculateParallel(out List<CurvePoint> pointQH, out List<CurvePoint> pointQE, out List<CurvePoint> pointQP)
        {
            pointQH = pointQE = pointQP = null;
            //求H的最大最小值
            if (!CalculateMaxMinH())
                return false;

            //计算并联
            return GetCurveParallel(out pointQH, out pointQE, out pointQP);
        }

        /// <summary>
        /// 从并联曲线中分割出单泵曲线
        /// </summary>
        /// <param name="connectPointsQH"></param>
        /// <param name="separatePointsQH"></param>
        /// <returns></returns>
        public bool SeparateParallelQH(List<CurvePoint> connectPointsQH, out List<CurvePoint> separatePointsQH)
        {
            separatePointsQH = new List<CurvePoint>();

            maxH = (from x in connectPointsQH select x.Y).Max();
            minH = (from x in connectPointsQH select x.Y).Min();

            int insert_num = 30;
            double space = (maxH - minH) / (insert_num - 1);

            double H = minH;
            int i = 0, j = 0;
            for (j = 0; j < insert_num; j++)
            {
                //计算流量
                List<CurvePoint> listQ = FitHelper.GetInterPointX(connectPointsQH, H);
                if (listQ == null || listQ.Count == 0)
                {
                    continue;
                }
                double totalQ = listQ.Last().X;
                bool isInsect = true;
                for (i = 0; i < _curveQhList.Count(); i++)
                {
                    var currentQH = _curveQhList[i];
                    //计算流量
                    List<CurvePoint> listQ2 = FitHelper.GetInterPointX(currentQH, H);
                    if (listQ2 == null || listQ2.Count == 0)
                    {
                        isInsect = false;
                        continue;
                    }
                    double Q = listQ2.Last().X;
                    totalQ = totalQ - Q;
                }

                //添加到列表
                if (isInsect)
                {
                    separatePointsQH.Add(new CurvePoint(totalQ, H));
                }

                H = H + space;
            }

            if (separatePointsQH.Count < 3)
            {
                separatePointsQH = null;
                return false;
            }

            var express = FitHelper.BuildCurveExpress(separatePointsQH, eFitType.CubicCurve);
            separatePointsQH = FitHelper.GetFitPoints(express, 20);
            return true;
        }


        //计算串联
        public bool CalculateSeries(
            out List<CurvePoint> pointsQH,
            out List<CurvePoint> pointsQE,
            out List<CurvePoint> pointsQP)
        {
            pointsQH = pointsQE = pointsQP = null;
            //求Q的最大最小值
            if (!CalculateMaxMinQ())
                return false;

            //计算并联
            return GetCurveSeries(out pointsQH, out pointsQE, out pointsQP);
        }


        private bool CalculateMaxMinH()
        {
            if (_curveQhList == null || _curveQhList.Count() == 0)
                return false;
            foreach (var curves in _curveQhList)
            {
                if (curves == null)
                    continue;
                double min_h = 0, max_h = 0;
                GetMinMaxPointYByRatio(curves, _extendMinRatio, _extendMaxRatio, out max_h, out min_h);
                this.minH = Math.Max(min_h, this.minH);
                this.maxH = Math.Min(max_h, this.maxH);

            }
            if (this.maxH * 0.99 < this.minH)
                return false;
            return true;
        }

        private bool CalculateMaxMinQ()
        {
            if (_curveQhList == null || _curveQhList.Count() == 0)
                return false;
            foreach (var curve in _curveQhList)
            {
                if (curve == null)
                    continue;

                minQ = Math.Max(curve.Min * _extendMinRatio, minH);
                maxQ = Math.Min(curve.Max * _extendMaxRatio, maxH);
            }

            if (minQ > maxQ - 3)
                return false;
            else
                return true;
        }

        //计算并联
        private bool GetCurveParallel(out List<CurvePoint> pointsQH, out List<CurvePoint> pointsQE, out List<CurvePoint> pointsQP)
        {
            if (_curveQhList == null || !_curveQhList.Any())
            {
                pointsQH = null;
                pointsQE = null;
                pointsQP = null;
                return false;
            }

            pointsQH = new List<CurvePoint>();
            pointsQE = new List<CurvePoint>();
            pointsQP = new List<CurvePoint>();

            int insert_num = 30;
            double space = (maxH - minH) / (insert_num - 1);

            double H = minH;
            int i = 0, j = 0;
            for (j = 0; j < insert_num; j++)
            {
                double totalQ = 0;
                double totalP = 0;
                bool isInsect = true;
                for (i = 0; i < _curveQhList.Count(); i++)
                {
                    CurveExpress currentQH = _curveQhList[i];
                    CurveExpress currentQP = null;
                    if (_curveQpList != null && _curveQpList.Count > i)
                        currentQP = _curveQpList[i];

                    //计算流量
                    List<CurvePoint> listQ = FitHelper.GetInterPointX(currentQH, H);
                    if (listQ == null || listQ.Count == 0)
                    {
                        isInsect = false;
                        continue;
                    }
                    double Q = listQ.Last().X;
                    totalQ = totalQ + Q;

                    //计算功率
                    if (currentQP != null)
                    {
                        double p = FitHelper.GetFitPointY(currentQP, Q);
                        totalP = totalP + p;
                    }
                }

                //添加到列表
                if (isInsect)
                {
                    pointsQH.Add(new CurvePoint(totalQ, H));
                    if (totalP > 0.001)
                    {
                        pointsQP.Add(new CurvePoint(totalQ, totalP));

                        double E = PumpCalculateHelper.CalculateE(totalQ, H, totalP);
                        pointsQE.Add(new CurvePoint(totalQ, E));
                    }
                }

                H = H + space;
            }

            //根据流量排序
            CurvePointComparer.Sort featPointComp = new CurvePointComparer.Sort(CurvePointComparer.eSortType.X);
            pointsQH.Sort(featPointComp);
            if (pointsQE != null && pointsQE.Count > 2)
                pointsQE.Sort(featPointComp);
            if (pointsQP != null && pointsQP.Count > 2)
                pointsQP.Sort(featPointComp);

            return true;
        }

        //计算串联
        private bool GetCurveSeries(out List<CurvePoint> pointsQH, out List<CurvePoint> pointsQE, out List<CurvePoint> pointsQP)
        {
            if (_curveQhList.Count() == 0)
            {
                pointsQH = null;
                pointsQE = null;
                pointsQP = null;
                return false;
            }
            pointsQH = new List<CurvePoint>();
            pointsQE = new List<CurvePoint>();
            pointsQP = new List<CurvePoint>();

            int insert_num = 30;
            double space = (maxQ - minQ) / (insert_num - 1);

            double Q = minQ;
            int i = 0, j = 0;
            for (j = 0; j < insert_num; j++)
            {
                double totalH = 0;
                double totalP = 0;
                bool isInsect = true;
                for (i = 0; i < _curveQhList.Count(); i++)
                {
                    CurveExpress currentQH = _curveQhList[i];
                    CurveExpress currentQP = null;
                    if (_curveQpList != null && _curveQpList.Count > i)
                        currentQP = _curveQpList[i];

                    //计算H
                    double h = FitHelper.GetFitPointY(currentQH, Q);
                    totalH = totalH + h;

                    //计算功率
                    if (currentQP != null)
                    {
                        double p = FitHelper.GetFitPointY(currentQP, Q);

                        totalP = totalP + p;
                    }
                }

                //添加到列表
                if (isInsect)
                {
                    pointsQH.Add(new CurvePoint(Q, totalH));
                    if (totalP > 0.001)
                    {
                        pointsQP.Add(new CurvePoint(Q, totalP));

                        double E = PumpCalculateHelper.CalculateE(Q, totalH, totalP);
                        pointsQE.Add(new CurvePoint(Q, E));
                    }
                }

                Q = Q + space;
            }

            //根据流量排序
            CurvePointComparer.Sort featPointComp = new CurvePointComparer.Sort(CurvePointComparer.eSortType.X);
            pointsQH.Sort(featPointComp);
            if (pointsQE != null && pointsQE.Count > 2)
                pointsQE.Sort(featPointComp);
            if (pointsQP != null && pointsQP.Count > 2)
                pointsQP.Sort(featPointComp);

            return true;
        }

        /// <summary>
        /// 获取拟合点(延长率):和GetFitPointsByExtend一模一样
        /// </summary>
        public static List<CurvePoint> GetFitPointsByRatio(CurveExpress express, double ratioExtendmin, double ratioExtendmax, int pointNumber)
        {
            if (express == null)
                return default;
            return express.GetFitPointsByXRange(express.Min * ratioExtendmin, express.Max * ratioExtendmax, pointNumber);
        }

        //获取延长后 MaxY MinY
        public static bool GetMinMaxPointYByRatio(CurveExpress express, double ratioExtendmin, double ratioExtendmax, out double maxY, out double minY)
        {
            if (express == null)
            {
                maxY = minY = 0;
                return false;
            }
            var fitPoints = GetFitPointsByRatio(express, ratioExtendmin, ratioExtendmax, 50);
            if (fitPoints == null || !fitPoints.Any())
            {
                maxY = minY = 0;
                return false;
            }
            maxY = (from x in fitPoints select x.Y).Max();
            minY = (from x in fitPoints select x.Y).Min();
            return true;
        }
    }
}