using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.ComponentModel;

namespace IStation.Model
{

    /// <summary>
    /// 曲线表达式
    /// </summary>
    [DataContract]
    public class CurveExpress : ICloneable
    {
        #region 构造函数

        public CurveExpress() { }
        public CurveExpress(CurveExpress rhs)
        {
            this.FitPow = rhs.FitPow;
            this.FitType = rhs.FitType;
            this.Min = rhs.Min;
            this.Max = rhs.Max;
            this.Index0 = rhs.Index0;
            this.Index1 = rhs.Index1;
            this.Index2 = rhs.Index2;
            this.Index3 = rhs.Index3;
            this.DefinePoints = rhs.DefinePoints?.Select(x => new CurvePoint(x)).ToList();
            this.IsNull = rhs.IsNull;
        }
        public CurveExpress(CurveExpress rhs, double ratio_y)
        {
            this.FitPow = rhs.FitPow;
            this.FitType = rhs.FitType;
            this.Min = rhs.Min;
            this.Max = rhs.Max;
            this.Index0 = rhs.Index0 * ratio_y;
            this.Index1 = rhs.Index1 * ratio_y;
            this.Index2 = rhs.Index2 * ratio_y;
            this.Index3 = rhs.Index3 * ratio_y;
            this.DefinePoints = rhs.DefinePoints?.Select(x => new CurvePoint(x.X, x.Y * ratio_y)).ToList();
            this.IsNull = rhs.IsNull;
        }
        public CurveExpress(string strParas)
        {
            if (string.IsNullOrEmpty(strParas))
            {
                this.IsNull = true;
                return;
            }
            var str_list = strParas.Split(new string[] { Separator }, StringSplitOptions.RemoveEmptyEntries);
            var count = str_list.Count();
            if (count < 8)
            {
                this.IsNull = true;
                return;
            }
            this.IsNull = false ;
            this.FitPow = Convert.ToInt32(str_list[0]);
            this.FitType = (eCurveFitType)Convert.ToInt32(str_list[1]);
            this.Min = Convert.ToDouble(str_list[2]);
            this.Max = Convert.ToDouble(str_list[3]);
            this.Index0 = Convert.ToDouble(str_list[4]);
            this.Index1 = Convert.ToDouble(str_list[5]);
            this.Index2 = Convert.ToDouble(str_list[6]);
            this.Index3 = Convert.ToDouble(str_list[7]);
            if (count > 8)
            {
                this.DefinePoints = CurvePoint.ToList(str_list[8]);
            }
        }
        public CurveExpress(List<CurvePoint> points)
        {
            ResetCurve(points, eCurveFitType.CubicCurve, false);
        }
        public CurveExpress(List<CurvePoint> points, bool savePoints)
        {
            ResetCurve(points, eCurveFitType.CubicCurve, savePoints);
        }
        public CurveExpress(List<CurvePoint> points, eCurveFitType fitType)
        {
            ResetCurve(points, fitType,false);
        }
        public CurveExpress(List<CurvePoint> points, eCurveFitType fitType, bool savePoints)
        {
            ResetCurve(points, fitType, savePoints);
        }
        public CurveExpress(List<CurvePoint> points, int fitPow)
        {
            ResetCurve(points, fitPow,false);
        }
        public CurveExpress(List<CurvePoint> points, int fitPow, bool savePoints)
        {
            ResetCurve(points, fitPow, savePoints);
        }

        /// <summary>
        /// 重置曲线
        /// </summary>
        public virtual void ResetCurve(CurveExpress rhs)
        {
            this.FitPow = rhs.FitPow;
            this.FitType = rhs.FitType;
            this.Min = rhs.Min;
            this.Max = rhs.Max;
            this.Index0 = rhs.Index0;
            this.Index1 = rhs.Index1;
            this.Index2 = rhs.Index2;
            this.Index3 = rhs.Index3;
            this.DefinePoints = rhs.DefinePoints?.Select(x => new CurvePoint(x)).ToList();
            this.IsNull = rhs.IsNull;
        }

        /// <summary>
        /// 重置曲线
        /// </summary>
        public virtual void ResetCurve(List<CurvePoint> points, eCurveFitType fitType, bool savePoints = false )
        {
            var express = FitCurveHelper.BuildCurveExpress(points, fitType);
            if (express == null)
            {
                this.IsNull = true;
                return;
            }
            if (express.IsNull)
            {
                this.IsNull = true;
                return;
            }
            this.FitType = express.FitType;
            this.FitPow = express.FitPow;
            this.Min = express.Min;
            this.Max = express.Max;
            this.Index0 = express.Index0;
            this.Index1 = express.Index1;
            this.Index2 = express.Index2;
            this.Index3 = express.Index3;
            this.IsNull = express.IsNull;
            if (savePoints)
            {
                this.DefinePoints = express.DefinePoints;
            }
            else if (fitType == eCurveFitType.ThroughPoint)
            {
                this.DefinePoints = express.DefinePoints;
            }
        }

        /// <summary>
        /// 重置曲线
        /// </summary>
        public virtual void ResetCurve(List<CurvePoint> points, int fitPow, bool savePoints = false )
        {
            var fitType = GetFitType(fitPow);
            this.ResetCurve(points, fitType, savePoints);
        }


        #endregion

        #region 静态值

        public const string Separator = "#";

        #endregion

        #region 属性

        /// <summary>
        /// 拟合次数
        /// </summary>
        [DataMember]
        public int FitPow
        {
            get { return fitPow; }
            set { fitPow = value; }
        }
        protected int fitPow = 3;

        /// <summary>
        /// 拟合类型
        /// </summary>
        [DataMember]
        public eCurveFitType FitType
        {
            get { return fitType; }
            set { fitType = value; }
        }
        protected eCurveFitType fitType = eCurveFitType.CubicCurve;

        /// <summary>
        /// 最大值
        /// </summary>
        [DataMember]
        public double Max
        {
            get { return max; }
            set { max = value; }
        }
        protected double max;

        /// <summary>
        /// 最小值
        /// </summary>
        [DataMember]
        public double Min
        {
            get { return min; }
            set { min = value; }
        }
        protected double min;

        /// <summary>
        /// 0次系数
        /// </summary>
        [DataMember]
        public double Index0
        {
            get { return index0; }
            set { index0 = value; }
        }
        protected double index0;

        /// <summary>
        /// 1次系数
        /// </summary>
        [DataMember]
        public double Index1
        {
            get { return index1; }
            set { index1 = value; }
        }
        protected double index1;

        /// <summary>
        /// 2次系数
        /// </summary>
        [DataMember]
        public double Index2
        {
            get { return index2; }
            set { index2 = value; }
        }
        protected double index2;

        /// <summary>
        /// 3次系数
        /// </summary>
        [DataMember]
        public double Index3
        {
            get { return index3; }
            set { index3 = value; }
        }
        protected double index3;

        /// <summary>
        /// 定义点
        /// </summary>
        [DataMember]
        public List<CurvePoint> DefinePoints
        {
            get { return definePoints; }
            set { definePoints = value; }
        }
        protected List<CurvePoint> definePoints = null;

        /// <summary>
        /// 是否为空
        /// </summary>
        [DataMember]
        public bool IsNull
        {
            get { return isNull; }
            set { isNull = value; }
        }
        protected bool isNull;


        #endregion


        /// <summary>
        /// 转化为保存字符串
        /// </summary>
        public string ToDsString()
        {
            var str_list = new List<string>();
            str_list.Add(this.FitPow.ToString());
            str_list.Add(((int)this.FitType).ToString());
            str_list.Add(this.Min.ToString());
            str_list.Add(this.Max.ToString());
            //str_list.Add(this.Index0.ToString());
            //str_list.Add(this.Index1.ToString("0.00000"));
            //str_list.Add(this.Index2.ToString("0.0000000000"));
            //str_list.Add(this.Index3.ToString("0.00000000000000"));

            //nsx
            var dc = new DoubleConverter();
            str_list.Add(dc.ConvertToString(this.Index0));
            str_list.Add(dc.ConvertToString(this.Index1));
            str_list.Add(dc.ConvertToString(this.Index2));
            str_list.Add(dc.ConvertToString(this.Index3));

            if (this.DefinePoints != null && this.DefinePoints.Count > 0)
            {
                str_list.Add(this.DefinePoints.ToDsString());
            }
            return string.Join(Separator, str_list);
        }

        object ICloneable.Clone()
        {
            return Clone();
        }

        public CurveExpress Clone()
        {
            return new CurveExpress(this);
        }

        /// <summary>
        /// 是否在内部
        /// </summary>
        public bool IsInterior(double x)
        {
            if (x < Min)
                return false;
            if (x > Max)
                return false;
            return true;
        }

        /// <summary>
        /// 获取拟合次方
        /// </summary>
        public static int GetFitPow(eCurveFitType fitType)
        {
            switch (fitType)
            {
                case eCurveFitType.CubicCurve: return 3;
                case eCurveFitType.ConicCurve: return 2;
                case eCurveFitType.ConicCurveB0: return 2;
                case eCurveFitType.LinearCurve: return 1;
                case eCurveFitType.ThroughPoint: return 0;
                default: return 3;
            }
        }

        /// <summary>
        /// 获取拟合类型
        /// </summary>
        public static eCurveFitType GetFitType(int fitPow)
        {
            switch (fitPow)
            {
                case 3: return eCurveFitType.CubicCurve;
                case 2: return eCurveFitType.ConicCurve;
                case 1: return eCurveFitType.LinearCurve;
                case 0: return eCurveFitType.ThroughPoint;
                default: return eCurveFitType.CubicCurve;
            }
        }

        /// <summary>
        /// 获取拟合点
        /// </summary>
        public double GetFitPointY(double x)
        {
            return FitCurveHelper.GetFitPointY(this, x);
        }

        /// <summary>
        /// 获取拟合点
        /// </summary>
        public List<CurvePoint> GetFitPoints(int pointNumber = 20)
        {
            if (this.IsNull)
                return default;
            return FitCurveHelper.GetFitPoints(this, pointNumber);
        }

        /// <summary>
        /// 通过区间内拟合点
        /// </summary>
        public List<CurvePoint> GetFitPointsByRange(double minX, double maxX, int pointNumber = 20)
        {
            if (this.IsNull)
                return default;
            return FitCurveHelper.GetFitPointsByRange(this, minX, maxX, pointNumber);
        }

        /// <summary>
        /// 获取拟合点
        /// </summary>
        public List<CurvePoint> GetFitPointsByExtend(double ratioExtend, int pointNumber = 20)
        {
            if (this.IsNull)
                return default;
            return GetFitPointsByRange(this.min, this.max * ratioExtend, pointNumber);
        }

        /// <summary>
        /// 获取第一个拟合点
        /// </summary>
        public CurvePoint GetFirstFitPoint()
        {
            return new CurvePoint(this.Min, GetFitPointY(this.Min));
        }

        /// <summary>
        /// 获取最后一个拟合点
        /// </summary>
        public CurvePoint GetLastFitPoint()
        {
            return new CurvePoint(this.Max, GetFitPointY(this.Max));
        }

        /// <summary>
        /// 获取零点的Y值
        /// </summary>
        public double GetZeroFitPointY()
        {
            return this.Index0;
        }

        /// <summary>
        /// 转换为Model
        /// </summary>
        public static CurveExpress ToModel(string strParas)
        {
            if (string.IsNullOrEmpty(strParas))
                return default;
            var express = new CurveExpress(strParas);
            if (express == null)
                return default;
            return express;
        }

        /// <summary>
        /// 是否相等
        /// </summary>
        public bool IsEquals(CurveExpress rhs)
        {
            if (rhs == null)
                return false;
            if (rhs.ToDsString().Equals(this.ToDsString()))
                return true;
            else
                return false;
        }

        /// <summary>
        /// 是否为Zero表达式
        /// </summary>
        public bool IsZeroExpress()
        {
            if (this.Index0 != 0)
                return false;
            if (this.Index1 != 0)
                return false;
            if (this.Index2 != 0)
                return false;
            if (this.Index3 != 0)
                return false;
            return true;
        }

        /// <summary>
        /// 通过 X转换
        /// </summary>
        public CurveExpress TransferX(double ratioX)
        {
            var fitPoints = this.GetFitPoints();
            fitPoints = fitPoints?.Select(x => new CurvePoint(x.X * ratioX, x.Y)).ToList();
            if (fitPoints == null || fitPoints.Count < 1)
                return default;
            var exp = new CurveExpress(fitPoints, this.FitType);
            var definePoints = this.DefinePoints?.Select(x => new CurvePoint(x.X * ratioX, x.Y)).ToList();
            if (definePoints != null && definePoints.Count > 0)
                exp.DefinePoints = definePoints;
            return exp;
        }

        /// <summary>
        /// 相似换算(speed_ratio = 新的转速 除以 老的转速)
        /// </summary>
        public CurveExpress SimuBySpeed(eFeatCurveType featType, double speed_ratio, int pointNumber = 20)
        {
            double space = (this.Max - this.Min) / (pointNumber - 1);
            switch (featType)
            {
                case eFeatCurveType.QH:
                    {
                        List<CurvePoint> pointInfo60 = new List<CurvePoint>();

                        for (int i = 0; i < pointNumber; i++)
                        {
                            double q50 = space * i + this.Min;
                            double q60 = q50 * speed_ratio;
                            double Y50 = GetFitPointY(q50);
                            pointInfo60.Add(new CurvePoint() { X = q60, Y = Y50 * speed_ratio * speed_ratio });
                        }

                        var new_curve = new CurveExpress(pointInfo60, this.FitType);
                        new_curve.DefinePoints = this.DefinePoints?.Select(x => new CurvePoint() { X = x.X * speed_ratio, Y = x.Y * speed_ratio * speed_ratio }).ToList();
                        return new_curve;
                    }
                case eFeatCurveType.QE:
                    {
                        List<CurvePoint> pointInfo60 = new List<CurvePoint>();

                        for (int i = 0; i < pointNumber; i++)
                        {
                            double q50 = space * i + this.Min;
                            double q60 = q50 * speed_ratio;
                            double Y50 = GetFitPointY(q50);
                            pointInfo60.Add(new CurvePoint() { X = q60, Y = Y50 });
                        }

                        var new_curve = new CurveExpress(pointInfo60, this.FitType);
                        return new_curve;
                    }
                case eFeatCurveType.QP:
                    {
                        List<CurvePoint> pointInfo60 = new List<CurvePoint>();

                        for (int i = 0; i < pointNumber; i++)
                        {
                            double q50 = space * i + this.Min;
                            double q60 = q50 * speed_ratio;
                            double Y50 = GetFitPointY(q50);
                            pointInfo60.Add(new CurvePoint() { X = q60, Y = Y50 * speed_ratio * speed_ratio * speed_ratio });
                        }

                        var new_curve = new CurveExpress(pointInfo60);
                        new_curve.DefinePoints = this.DefinePoints?.Select(x => new CurvePoint() { X = x.X * speed_ratio, Y = x.Y * speed_ratio * speed_ratio * speed_ratio }).ToList();
                        return new_curve;
                    }
                default:
                    {
                        List<CurvePoint> pointInfo60 = new List<CurvePoint>();

                        for (int i = 0; i < pointNumber; i++)
                        {
                            double q50 = space * i + this.Min;
                            double q60 = q50 * speed_ratio;
                            double Y50 = GetFitPointY(q50);
                            pointInfo60.Add(new CurvePoint() { X = q60, Y = Y50 });
                        }

                        var new_curve = new CurveExpress(pointInfo60);
                        new_curve.DefinePoints = this.DefinePoints?.Select(x => new CurvePoint() { X = x.X * speed_ratio, Y = x.Y }).ToList();
                        return new_curve;
                    }
            }
        }

        /// <summary>
        /// 50 到 60
        /// </summary>
        public CurveExpress SimuFrom50To60(eFeatCurveType featType, int pointNumber = 20)
        {
            return SimuBySpeed(featType, 1.2, pointNumber);
        }


        /// <summary>
        /// 曲线方程：用于显示
        /// </summary>
        public string GetCurveFunction(string xName = "Q")
        {
            //double signValue = 0;
            //int value = 0;

            StringBuilder sb = new StringBuilder();

            //sb.Append(this.index0.ToString("G"));
            //sb.Append(this.index0.ToString("0.00E+000"));//ToString("G"));
            sb.Append(Math.Abs(this.Index0).ToString("0.00"));//.ToString("G"));

            if (this.Index1 > 0)
                sb.Append(" + ");
            else
                sb.Append(" - ");
            //GetFuncScientificValue(1,Math.Abs(index1),ref signValue,ref value);
            //sb.AppendFormat("{0}E{1}",signValue,value);
            sb.Append(Math.Abs(this.Index1).ToString("0.0000"));//.ToString("G"));
            sb.Append(" * ");
            sb.Append(xName);


            if (this.Index2 > 0)
                sb.Append(" + ");
            else
                sb.Append(" - ");
            //GetFuncScientificValue(2,Math.Abs(index2),ref signValue,ref value);
            //sb.AppendFormat("{0}E{1}",signValue,value);
            //sb.Append(Math.Round(Math.Abs(this.index2),4).ToString("G"));//.ToString("G"));
            sb.Append(Math.Abs(this.Index2).ToString("0.000000000"));//.ToString("G"));
            sb.Append(" * ");
            sb.Append(xName);
            sb.Append("^2 ");


            if (this.Index3 > 0)
                sb.Append("  +  ");
            else
                sb.Append("  -  ");
            //GetFuncScientificValue(3,Math.Abs(index3),ref signValue,ref value);
            //sb.AppendFormat("{0}E{1}",signValue,value);
            //sb.Append(Math.Abs(this.index3).ToString("G"));//.ToString("G"));
            sb.Append(Math.Abs(this.Index3).ToString("0.000000000000"));//.ToString("G"));
            sb.Append(" * ");
            sb.Append(xName);
            sb.Append("^3 ");

            return sb.ToString();
        }

  
        private static void GetFuncScientificValue(int FunctionIndex,
            double FunctionCoeff, ref double signValue, ref int indexValue)
        {
            string strList = "";
            if (FunctionIndex == 0)
            {
                strList = FunctionCoeff.ToString("0.000e+000");
            }
            else if (FunctionIndex == 1)
            {
                strList = FunctionCoeff.ToString("0.000000e+000");
            }
            else if (FunctionIndex == 2)
            {
                strList = FunctionCoeff.ToString("#.#########e+000");
            }
            else if (FunctionIndex == 3)
            {
                strList = FunctionCoeff.ToString("#.############e+000");
            }
            string[] st1 = null;
            st1 = strList.Split('e');
            signValue = Convert.ToDouble(st1[0]);
            indexValue = Convert.ToInt32(st1[1]);
        }










    }
}