using DTS.Common.Enums.Sensors;
using System;
using System.Collections.Generic;
using System.Text;

namespace DTS.Common.DAS.Concepts
{
    public class LinearizationFormula
    {
        private bool _bIsValid;
        public bool IsValid() { return _bIsValid; }
        public void MarkValid(bool bValid)
        {
            _bIsValid = bValid;
        }


        // Translation
        public NonLinearSLICEWareStyles NonLinearSliceWareStyle
        {
            get => (NonLinearSLICEWareStyles)NonLinearStyle;
            set => NonLinearStyle = (NonLinearStyles)value;
        }

        public NonLinearStyles NonLinearStyle { get; set; } = NonLinearStyles.Polynomial; // Dont make the default style one that locks a specific zero-method FB 10323

        public double PolynomialSensitivity { get; set; } = 1D;

        public double LinearizationExponent { get; set; } = 1D;

        /// <summary>
        /// THIS IS MM/V, (UI has already been updated, we need to update the variable name)
        /// </summary>
        private double _mmPerMV;
        public double MMPerV
        {
            get => _mmPerMV;
            set => _mmPerMV = value;
        }

        public double MVAt0MM { get; set; }

        public double Slope { get; set; }

        public double Intercept { get; set; }

        public double CalibrationFactor { get; set; }

        public double ZeroPositionIntercept { get; set; }

        public LinearizationFormula()
        {
            ZeroPositionIntercept = 0D;
            CalibrationFactor = 0D;
            Intercept = 0D;
            _coefficients = new List<double>(new double[] { 0, 0, 0, 0 });
            _exponents = new List<double>(new double[] { 0, 1, 2, 3 });
        }

        public LinearizationFormula(LinearizationFormula copy)
        {
            UsemVOverVForPolys = copy.UsemVOverVForPolys;
            _bIsValid = copy._bIsValid;
            _coefficients = new List<double>(copy._coefficients.ToArray());
            _exponents = new List<double>(copy._exponents.ToArray());
            Intercept = copy.Intercept;
            LinearizationExponent = copy.LinearizationExponent;
            _mmPerMV = copy._mmPerMV;
            MVAt0MM = copy.MVAt0MM;
            Slope = copy.Slope;
            NonLinearStyle = copy.NonLinearStyle;
            _coefficients = new List<double>(copy._coefficients);
            _exponents = new List<double>(copy._exponents);
            PolynomialSensitivity = copy.PolynomialSensitivity;
            ZeroPositionIntercept = copy.ZeroPositionIntercept;
            CalibrationFactor = copy.CalibrationFactor;
        }
        public double GetCoefficient(double exponent)
        {
            for (var i = 0; i < _exponents.Count && i < _coefficients.Count; i++)
            {
                if (_exponents[i] == exponent) { return _coefficients[i]; }
            }
            return 0;
        }
        public void SetCoefficient(double exponent, double coefficient)
        {
            for (var i = 0; i < _exponents.Count && i < _coefficients.Count; i++)
            {
                if (_exponents[i] == exponent) { _coefficients[i] = coefficient; return; }
            }
        }
        public double GetLinearizedValue(double input, double excitation)
        {
            if (NonLinearStyle != NonLinearStyles.Polynomial && input <= 0)
            {
                //ir-tracc should never be < 0, however we may get readings less than zero due to
                //noise and other factors, treat these as positive near to zero
                input = .001;
            }
            //first linearize
            input /= 1000D;//assume input is in mV and we want it in Volts
            input = Math.Pow(input, LinearizationExponent);

            switch (NonLinearStyle)
            {
                case NonLinearStyles.IRTraccDiagnosticsZero:
                    return GetEUDiagnosticsZero(input);
                case NonLinearStyles.IRTraccManual:
                    return GetEUIRTraccManual(input);
                case NonLinearStyles.IRTraccZeroMMmV:
                    return GetEUZeroMMmV(input);
                case NonLinearStyles.IRTraccAverageOverTime:
                    return GetEUAverageOverTime(input);
                case NonLinearStyles.Polynomial:
                    return GetEUPolynomial(input, excitation);
                case NonLinearStyles.IRTraccCalFactor:
                    return GetEUIRTraccCalFactor(input);
                default:
                    throw new NotSupportedException("unknown format: " + NonLinearStyle);
            }
        }
        private double GetEUIRTraccCalFactor(double volts)
        {
            return volts * CalibrationFactor + ZeroPositionIntercept;
        }
        private double GetEUIRTraccManual(double volts)
        {
            return (volts - Intercept) / Slope;
        }

        public bool UsemVOverVForPolys { get; set; }

        private double GetEUZeroMMmV(double volts)
        {
            var input = MVAt0MM / 1000D;
            input = Math.Pow(input, LinearizationExponent);
            if (double.IsNaN(input) || double.IsNegativeInfinity(input) || double.IsPositiveInfinity(input))
            {
                return volts * MMPerV;
            }
            return (volts * MMPerV - MMPerV * input);
        }
        private List<double> _coefficients = new List<double>();
        private List<double> _exponents = new List<double>();
        private double GetEUPolynomial(double volts, double excitation)
        {
            //per J2517
            //3.4 Use of the Calibration Coefficients
            //The potentiometer assembly should be re-installed in the dummy without any mechanical adjustment of the
            //potentiometer. Prior to a crash test, the original zero offset level must be preserved by either not zeroing the
            //potentiometer (by signal conditioning or post-processing) or the amount that was zeroed must be added during postprocessing.
            //During the test the absolute voltage output time history should be recorded. This voltage signal is then
            //converted to engineering units by:
            //1. Convert voltage signal to mV/V at the sensor. This is the sensor reading S.
            //2. Convert the sensor reading S to displacement D by using the equation:
            //D = A*S^3 + B*S^2 + C*S + M (Eq. 2)
            //where:
            //D is the displacement relative to the thorax design position in mm
            //S is the sensor output reading in mV/V
            //A, B, C, and M are the calibration coefficients
            //NOTE: Make sure to use sufficient significant digits on all coefficients to assure accuracy of the conversion to
            //engineering units. It is recommended to use 5 significant digits (example 0.000012345).

            //double mV = volts * 1000D;
            //double gain = 1D;
            //mV = mV / (gain * excitation);

            //if (0 != PolynomialSensitivity && 1!= PolynomialSensitivity) { mV /= PolynomialSensitivity; }
            //double eu = 0D;
            //for (int i = 0; i < _coefficients.Count && i < _exponents.Count; i++)
            //{
            //    eu += _coefficients[i] * Math.Pow(mV, _exponents[i]);
            //}
            //return eu;

            //CHANGED FOR GM TESTING

            if (0 != PolynomialSensitivity && 1 != PolynomialSensitivity)
            {
                volts /= PolynomialSensitivity;
            }

            var voltsOverV = 0D;
            if (UsemVOverVForPolys)
            {
                //convert to mV first
                voltsOverV = (volts * 1000D) / excitation;
            }
            else
            {
                //used by GM
                voltsOverV = volts / excitation;
            }
            double eu = 0;

            for (var i = 0; i < _coefficients.Count && i < _exponents.Count; i++)
            {
                if (_exponents[i] != 0)
                {
                    eu += _coefficients[i] * Math.Pow(voltsOverV, _exponents[i]);
                }
                else
                {
                    eu += _coefficients[i];
                }
            }
            return eu;
        }
        /// <summary>
        /// MvAt0MM set at diagnostics
        /// </summary>
        /// <param name="volts"></param>
        /// <returns></returns>
        private double GetEUDiagnosticsZero(double volts)
        {
            //double input = MVAt0MM/1000D;
            //input = System.Math.Pow(input,LinearizationExponent);
            var input = double.NaN;
            if (double.IsNaN(input) || double.IsPositiveInfinity(input) || double.IsNegativeInfinity(input))
            {
                return volts * MMPerV;
            }
            return volts * MMPerV - MMPerV * input;
        }
        /// <summary>
        /// MVAt0MM set by diagnostics and then later on at
        /// Average Over Time
        /// </summary>
        /// <param name="volts"></param>
        /// <returns></returns>
        private double GetEUAverageOverTime(double volts)
        {
            //double input = MVAt0MM / 1000D;
            //input = System.Math.Pow(input, LinearizationExponent);
            var input = double.NaN;
            if (double.IsNaN(input) || double.IsNegativeInfinity(input) || double.IsPositiveInfinity(input))
            {
                return volts * MMPerV;
            }
            return volts * MMPerV - MMPerV * input;
        }


        public string ToSLICEWareSerializeString()
        {
            if (!_bIsValid) { return ""; }
            var sb = new StringBuilder();
            sb.AppendFormat("{0}_", NonLinearStyle);

            switch (NonLinearStyle)
            {
                case NonLinearStyles.IRTraccDiagnosticsZero:
                    sb.Append(ToIRTraccDiagnosticZeroString());
                    break;
                case NonLinearStyles.IRTraccManual:
                    sb.Append(ToIRTraccManualString());
                    break;
                case NonLinearStyles.IRTraccZeroMMmV:
                    sb.Append(ToIRTraccZeroMMmVString());
                    break;
                case NonLinearStyles.IRTraccAverageOverTime:
                    sb.Append(ToIRTraccAverageOverTimeString());
                    break;
                case NonLinearStyles.Polynomial:
                    sb.Append(ToSLICEWarePolynomialString());
                    break;
                case NonLinearStyles.IRTraccCalFactor:
                    throw new NotSupportedException("CalFactor not supported in SLICEWare");
                default:
                    throw new NotSupportedException("unknown type: " + NonLinearStyle);
            }

            return sb.ToString();
        }

        /// <summary>
        /// serializes to a string of the format "c0xe0 c1xe1...cnxen"
        /// this will allow us arbitrary length polynomials and fractional exponents.
        /// </summary>
        /// <returns></returns>
        public string ToSerializeString()
        {
            if (!_bIsValid) { return ""; }
            var sb = new StringBuilder();
            sb.AppendFormat("{0}_", NonLinearStyle);

            switch (NonLinearStyle)
            {
                case NonLinearStyles.IRTraccDiagnosticsZero:
                    sb.Append(ToIRTraccDiagnosticZeroString());
                    break;
                case NonLinearStyles.IRTraccManual:
                    sb.Append(ToIRTraccManualString());
                    break;
                case NonLinearStyles.IRTraccZeroMMmV:
                    sb.Append(ToIRTraccZeroMMmVString());
                    break;
                case NonLinearStyles.IRTraccAverageOverTime:
                    sb.Append(ToIRTraccAverageOverTimeString());
                    break;
                case NonLinearStyles.Polynomial:
                    sb.Append(ToPolynomialString());
                    break;
                case NonLinearStyles.IRTraccCalFactor:
                    sb.Append(ToIRTraccCalFactorString());
                    break;
                default:
                    throw new NotSupportedException("unknown type: " + NonLinearStyle);
            }

            return sb.ToString();
        }
        public string ToIRTraccDiagnosticZeroString()
        {
            return $"{MMPerV.ToString(System.Globalization.CultureInfo.InvariantCulture)}x{LinearizationExponent.ToString(System.Globalization.CultureInfo.InvariantCulture)}";
        }
        public string ToIRTraccCalFactorString()
        {
            return $"{CalibrationFactor.ToString(System.Globalization.CultureInfo.InvariantCulture)}x{LinearizationExponent.ToString(System.Globalization.CultureInfo.InvariantCulture)}x{ZeroPositionIntercept.ToString(System.Globalization.CultureInfo.InvariantCulture)}";
        }
        public void FromIRTraccCalFactorString(string s, System.Globalization.CultureInfo culture)
        {
            var tokens = s.Split('x');
            if (tokens.Length < 3) { throw new NotSupportedException("Invalid CalFactor format: " + s); }

            CalibrationFactor = double.Parse(tokens[0], culture);
            LinearizationExponent = double.Parse(tokens[1], culture);
            ZeroPositionIntercept = double.Parse(tokens[2], culture);
        }
        public void FromIRTraccDiagnosticZeroString(string s, System.Globalization.CultureInfo culture)
        {
            var tokens = s.Split('x');
            if (tokens.Length < 2) { throw new NotSupportedException("Invalid DiagnosticsZero format: " + s); }
            MMPerV = double.Parse(tokens[0], culture);
            LinearizationExponent = double.Parse(tokens[1], culture);
        }
        public string ToIRTraccManualString()
        {
            return $"{Slope.ToString(System.Globalization.CultureInfo.InvariantCulture)}x{Intercept.ToString(System.Globalization.CultureInfo.InvariantCulture)}x{LinearizationExponent.ToString(System.Globalization.CultureInfo.InvariantCulture)}";
        }
        public void FromIRTraccManualString(string s, System.Globalization.CultureInfo culture)
        {
            var tokens = s.Split('x');
            if (tokens.Length < 3) { throw new NotSupportedException("Invalid IRTraccManual format: " + s); }
            Slope = double.Parse(tokens[0], culture);
            Intercept = double.Parse(tokens[1], culture);
            LinearizationExponent = double.Parse(tokens[2], culture);
        }
        public string ToIRTraccZeroMMmVString()
        {
            return $"{MMPerV.ToString(System.Globalization.CultureInfo.InvariantCulture)}x{MVAt0MM.ToString(System.Globalization.CultureInfo.InvariantCulture)}x{LinearizationExponent.ToString(System.Globalization.CultureInfo.InvariantCulture)}";
        }
        public string ToSLICEWarePolynomialString()
        {
            //SLICEWare is the reverse order of our DataPRO Database
            var sb = new StringBuilder();
            for (var i = _exponents.Count - 1; i >= 0; i--)
            {
                if (i != _exponents.Count - 1) { sb.Append(","); }
                sb.AppendFormat("{0}x{1}", _coefficients[i].ToString(System.Globalization.CultureInfo.InvariantCulture),
                    _exponents[i].ToString(System.Globalization.CultureInfo.InvariantCulture));
            }

            sb.AppendFormat(",S={0}", PolynomialSensitivity.ToString(System.Globalization.CultureInfo.InvariantCulture));
            return sb.ToString();
        }
        public string ToPolynomialString()
        {
            var sb = new StringBuilder();
            for (var i = 0; i < _coefficients.Count && i < _exponents.Count; i++)
            {
                if (i > 0) { sb.Append(","); }
                sb.AppendFormat("{0}x{1}", _coefficients[i].ToString(System.Globalization.CultureInfo.InvariantCulture),
                    _exponents[i].ToString(System.Globalization.CultureInfo.InvariantCulture));
            }

            sb.AppendFormat(",S={0},mV={1}",
                PolynomialSensitivity.ToString(System.Globalization.CultureInfo.InvariantCulture),
                UsemVOverVForPolys.ToString(System.Globalization.CultureInfo.InvariantCulture));

            return sb.ToString();
        }
        public double[] PolynomialCoefficients
        {
            get => _coefficients.ToArray();
            set => _coefficients = new List<double>(value);
        }
        public double[] PolynomialExponents
        {
            get => _exponents.ToArray();
            set => _exponents = new List<double>(value);
        }
        public string ToIRTraccAverageOverTimeString()
        {
            return $"{MMPerV.ToString(System.Globalization.CultureInfo.InvariantCulture)}x{LinearizationExponent.ToString(System.Globalization.CultureInfo.InvariantCulture)}";
        }
        public void FromIRTraccAverageOverTimeString(string s, System.Globalization.CultureInfo culture)
        {
            var tokens = s.Split('x');
            if (tokens.Length < 2) { throw new NotSupportedException("Invalid IRTRaccAverageOverTime format: " + s); }
            MMPerV = double.Parse(tokens[0], culture);
            LinearizationExponent = double.Parse(tokens[1], culture);
        }
        public void FromIRTraccZeroMMmVString(string s, System.Globalization.CultureInfo culture)
        {
            var tokens = s.Split('x');
            if (tokens.Length < 3) { throw new NotSupportedException("Invalid IRTraccZeroMMmV format: " + s); }
            MMPerV = double.Parse(tokens[0], culture);
            MVAt0MM = double.Parse(tokens[1], culture);
            LinearizationExponent = double.Parse(tokens[2], culture);
        }
        public void FromPolynomialString(string s, System.Globalization.CultureInfo culture)
        {
            _coefficients.Clear();
            _exponents.Clear();

            var tokens = s.Split(',');
            foreach (var t in tokens)
            {
                var subtokens = t.Split('x');
                if (2 == subtokens.Length)
                {
                    if (double.TryParse(subtokens[0], System.Globalization.NumberStyles.Float, culture, out var d))
                    {
                        _coefficients.Add(d);
                        _exponents.Add(double.Parse(subtokens[1], culture));
                    }
                    else
                    {
                        PolynomialSensitivity = double.Parse(subtokens[1], culture);
                    }
                }
                else
                {
                    subtokens = t.Split('=');
                    if (subtokens.Length == 2)
                    {
                        switch (subtokens[0])
                        {
                            case "S":
                                PolynomialSensitivity = double.Parse(subtokens[1], culture);
                                break;
                            case "mV":
                                UsemVOverVForPolys = Convert.ToBoolean(subtokens[1], culture);
                                break;
                        }
                    }
                }
            }
        }
        public void FromSerializeString(string s, System.Globalization.CultureInfo culture)
        {
            if (string.IsNullOrEmpty(s)) { _bIsValid = false; return; }
            if (s.Equals("1") || s.Equals("0") || s.Equals("1 ")) { _bIsValid = false; return; }

            var tokens = s.Split('_');
            if (tokens.Length < 2) { throw new NotSupportedException("unsupported Linearization Formula Format"); }
            var style = (NonLinearStyles)Enum.Parse(typeof(NonLinearStyles), tokens[0], true);
            NonLinearStyle = style;
            switch (NonLinearStyle)
            {
                case NonLinearStyles.IRTraccDiagnosticsZero:
                    FromIRTraccDiagnosticZeroString(tokens[1], culture);
                    _bIsValid = true;
                    break;
                case NonLinearStyles.IRTraccManual:
                    FromIRTraccManualString(tokens[1], culture);
                    _bIsValid = true;
                    break;
                case NonLinearStyles.IRTraccZeroMMmV:
                    FromIRTraccZeroMMmVString(tokens[1], culture);
                    _bIsValid = true;
                    break;
                case NonLinearStyles.Polynomial:
                    FromPolynomialString(tokens[1], culture);
                    _bIsValid = true;
                    break;
                case NonLinearStyles.IRTraccAverageOverTime:
                    FromIRTraccAverageOverTimeString(tokens[1], culture);
                    _bIsValid = true;
                    break;
                case NonLinearStyles.IRTraccCalFactor:
                    FromIRTraccCalFactorString(tokens[1], culture);
                    _bIsValid = true;
                    break;
                default:
                    throw new NotSupportedException("Unknown format: " + NonLinearStyle);
            }
        }
        public void FromSerializeString(string s)
        {
            FromSerializeString(s, System.Globalization.CultureInfo.InvariantCulture);
        }

        public void FromTDCSerializeString()
        {
            _bIsValid = true;
        }

        /// <summary>
        /// Will return a display string for a nonlinear calibration based on N4 formating
        /// </summary>
        public string ToDisplayString()
        {
            return ToDisplayString("N4");
        }
        /// <summary>
        /// Will return a display string for a nonlinear calibration based on 1st paramater formating string
        /// </summary>
        /// <param name="nonlinearFormat"></param>
        /// <returns></returns>
        public string ToDisplayString(string nonlinearFormat)
        {
            if (string.IsNullOrEmpty(nonlinearFormat)) { nonlinearFormat = "N4"; }
            switch (NonLinearStyle)
            {
                case NonLinearStyles.Polynomial:
                    {
                        return ToPolynomial(nonlinearFormat);
                    }
                case NonLinearStyles.IRTraccZeroMMmV:
                    {
                        return $"mV = {MVAt0MM:n4}, {MMPerV:n4}*(V^{ToSuperScript(LinearizationExponent.ToString(nonlinearFormat))})";
                    }
                case NonLinearStyles.IRTraccManual:
                    {
                        return $"((V^{ToSuperScript(LinearizationExponent.ToString(nonlinearFormat))})-{Intercept:n4})/{Slope:n4}";
                    }
                case NonLinearStyles.IRTraccDiagnosticsZero:
                    {
                        return $"{MMPerV:n4}*(V^{ToSuperScript(LinearizationExponent.ToString(nonlinearFormat))})";
                    }
                case NonLinearStyles.IRTraccAverageOverTime:
                    {
                        return $"{MMPerV:n4}*(V^{ToSuperScript(LinearizationExponent.ToString(nonlinearFormat))})";
                    }
                case NonLinearStyles.IRTraccCalFactor:
                    {
                        return $"{ZeroPositionIntercept:n4}+{CalibrationFactor:n4}*(V^{ToSuperScript(LinearizationExponent.ToString(nonlinearFormat))})";
                    }
                default:
                    return string.Empty;
            }
        }
        private string ToPolynomial(string nonlinearFormat)
        {
            if (string.IsNullOrEmpty(nonlinearFormat)) { nonlinearFormat = "N4"; }

            var sb = new StringBuilder();

            var termNumber = PolynomialCoefficients.Length - 1;
            foreach (var x in PolynomialCoefficients)
            {
                if (PolynomialCoefficients[termNumber] != 0)
                {
                    var coeff = PolynomialCoefficients[termNumber];

                    // Let the appended math symbol handle sign unless we're the first term.
                    if (termNumber != PolynomialCoefficients.Length - 1)
                    {
                        coeff = Math.Abs(coeff);
                    }
                    sb.Append(coeff.ToString(nonlinearFormat));
                    if (PolynomialExponents[termNumber] != 0)
                    {
                        sb.Append("x");
                        if (PolynomialExponents[termNumber] != 1)
                        {
                            sb.Append(ToSuperScript(PolynomialExponents[termNumber].ToString("N0")));
                        }
                    }
                    if (termNumber > 0)
                    {
                        // Coerricients are Displayed in absolute value. We need to combine the sign with the addition symbol
                        sb.Append(PolynomialCoefficients[termNumber - 1] > 0 ? " + " : " - ");
                    }
                }
                termNumber--;
            }

            return sb.ToString();
        }
        private string ToSuperScript(string source)
        {
            var superScript = new StringBuilder();

            foreach (var c in source)
            {
                switch (c)
                {
                    case '-':
                        superScript.Append('\u207B');
                        break;
                    case '.':
                        superScript.Append('\u00B7');
                        break;
                    case '1':
                        superScript.Append('\u00B9');
                        break;
                    case '2':
                        superScript.Append('\u00B2');
                        break;
                    case '3':
                        superScript.Append('\u00B3');
                        break;
                    case '4':
                        superScript.Append('\u2074');
                        break;
                    case '5':
                        superScript.Append('\u2075');
                        break;
                    case '6':
                        superScript.Append('\u2076');
                        break;
                    case '7':
                        superScript.Append('\u2077');
                        break;
                    case '8':
                        superScript.Append('\u2078');
                        break;
                    case '9':
                        superScript.Append('\u2079');
                        break;
                    case '0':
                        superScript.Append('\u2070');
                        break;
                    case '\'':
                        superScript.Append('\u02C8');
                        break;
                    case ',':
                        superScript.Append('\u22C5'); // there is no unicode superscript comma. this comes close
                        break;
                    case '\u00A0':
                        superScript.Append('\u2009'); // unicode 'thin' space
                        break;
                    default:
                        superScript.Append('\u207F');
                        break;
                }
            }

            return superScript.ToString();
        }
        /*
         * we are given an equation in the form of y = ax^1 + b, except x and y are backwards for us (y=V where we'd prefer X was voltage, so we switch it)
         * y/a - b/a = x, and then switch y and x, (1/a)x^1 -(b/a)x^0 = y
         * now we want to get the coefficient of the first equation, which is "a", we get this by taking the inverse
         * we get b on the other hand by taking -1 * (b/a)*a.  if we have the "coefficient", we have a
         */
        /*
        public double GetIRTraccCoefficient()
        {
            foreach (Factor f in Factors)
            {
                if (f.Exponent == 1D) { return System.Math.Pow(f.Coefficient, -1); }
            }
            return 1D; //0 doesn't make sense for ir
        }
        public double GetIRTraccConstant()
        {
            foreach (Factor f in Factors)
            {
                if (f.Exponent == 0D) { return -1D * GetIRTraccCoefficient() * f.Coefficient; }
            }
            return 0D;
        }
        public void SetIRTraccFactor(double coefficient, double constant)
        {
            if (0 == coefficient)
            {
                //well this doesn't make any sense ...
                coefficient = 1;
            }
            Factors = new Factor[]
            {
                new Factor(1/coefficient,1),
                new Factor(-constant/coefficient,0),
            };
        }*/
    }
}