//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.ComponentModel;
using System.Globalization;
using System.Numerics;
using System.Text;

namespace OpenTap
{
    /// <summary> Arbitrary precision floating point numbers for exact numeric computations for when performance is not an issue. </summary>
    [TypeConverter(typeof(BigFloatConverter))]
    struct BigFloat : IFormattable, IComparable, IComparable<BigFloat>, IEquatable<BigFloat>
    {
        /// <summary> The numerator as an arbitrarily sized integer. </summary>
        BigInteger Numerator;
        /// <summary> The denominator as an arbitrarily sized integer. </summary>
        BigInteger Denominator;

        /// <summary> Creates a new BigFloat from fractional values. </summary>
        /// <param name="nominator"></param>
        /// <param name="denominator"></param>
        public BigFloat(BigInteger nominator, BigInteger denominator)
        {
            Numerator = nominator;
            Denominator = denominator;
            Normalize();
        }

        public BigFloat Invert()
        {
            return new BigFloat { Numerator = Denominator, Denominator = Numerator };
        }

        /// <summary> Normalizes the fraction by dividing by greates common divisor. </summary>
        /// <returns>The normalized fraction.</returns>
        public BigFloat Normalize()
        {
            if(Denominator == 0)
            {
                if(Numerator > 1)
                {
                    Numerator = 1;
                }else if(Numerator < -1)
                {
                    Numerator = -1;
                }
                return this;
            }
            else if (Denominator == Numerator)
            {
                Numerator = 1;
                Denominator = 1;
            }

            if (Denominator < 0)
            {
                Numerator *= -1;
                Denominator *= -1;
            }

            BigInteger gcd = BigInteger.GreatestCommonDivisor(Numerator, Denominator);
            if (Denominator == gcd)
            {
                Numerator = Numerator / gcd;
                Denominator = 1;
                return this;
            }
            Numerator = Numerator / gcd;
            Denominator = Denominator / gcd;
            return this;
        }
        static char getDigitSeparator(IFormatProvider prov)
        {
            if (prov == null)
                prov = CultureInfo.CurrentCulture;
            if(prov is CultureInfo)
            {
                return ((CultureInfo)prov).NumberFormat.NumberDecimalSeparator[0];
            }
            if(prov is NumberFormatInfo)
            {
                return ((NumberFormatInfo)prov).NumberDecimalSeparator[0];
            }
            return '.';
        }

        static string fracToString(BigInteger a, BigInteger b, IFormatProvider prov)
        {
            var sb = new StringBuilder();
            fracToString(sb, a, b, prov);
            return sb.ToString();
        }
        
        static void fracToString(StringBuilder sb, BigInteger a, BigInteger b, IFormatProvider prov)
        {
            if (prov == null)
                prov = CultureInfo.CurrentCulture.NumberFormat;
            var digits = (int)Math.Ceiling(BigInteger.Log10(a) - BigInteger.Log10(b));
            
            if (digits < 0)
                sb.Append("0" + getDigitSeparator(prov));

            bool firstDigitFound = false;
            int firstDigit = 0;

            BigInteger ten = 10;

            while (digits >= 0 || firstDigitFound == false || (firstDigit - digits) < 15)
            {
                if (a == 0 && digits < 0)
                    break;
                BigInteger newb = b;
                
                if (digits >= 0)
                {
                    newb = b * BigInteger.Pow(ten, digits);
                }
                else if (digits < 0)
                {
                    a = a * 10;
                }
                var dig = (a / newb);
                if (dig != 0 && !firstDigitFound)
                {
                    firstDigitFound = true;
                    firstDigit = digits;
                }
                if (dig == 10)
                {
                    sb.Append("10");
                }
                else if (firstDigitFound || digits <= 0)
                {
                    sb.Append((char)('0' + (int)dig));
                }
                a = a - (dig * newb);
                if (digits == 0 && a != 0)
                    sb.Append(getDigitSeparator(prov));

                digits--;
            }
        }

        public void AppendTo(StringBuilder sb, IFormatProvider prov)
        {
            if (prov == null)
                prov = CultureInfo.CurrentCulture.NumberFormat;

            var numberFormat = CultureInfo.CurrentCulture.NumberFormat;

            if (prov is CultureInfo) numberFormat = (prov as CultureInfo).NumberFormat;
            else if (prov is NumberFormatInfo) numberFormat = (prov as NumberFormatInfo);
            
            if (Denominator == 0)
            {
                if (Numerator == 0){ 
                    sb.Append(numberFormat.NaNSymbol);
                    return;
                }
                else if (Numerator == 1)
                {
                    sb.Append(numberFormat.PositiveInfinitySymbol);
                    return;
                }
                else if (Numerator == -1)
                {
                    sb.Append(numberFormat.NegativeInfinitySymbol);
                    return;
                }
            }

            if (Numerator == 0)
            {
                sb.Append("0");
                return;
            }

            if (Denominator < 0)
            {
                Numerator *= -1;
                Denominator *= -1;
            }

            var num = Numerator;
            bool isNegative = false;
            if (num < 0)
            {
                num = -num;
                isNegative = true;
            }

            if (isNegative)
                sb.Append(numberFormat.NegativeSign);

            fracToString(sb, num, Denominator, prov);
        }

        public string ToString(IFormatProvider prov)
        {
            if (prov == null)
                prov = CultureInfo.CurrentCulture.NumberFormat;

            var numberFormat = CultureInfo.CurrentCulture.NumberFormat;

            if (prov is CultureInfo) numberFormat = (prov as CultureInfo).NumberFormat;
            else if (prov is NumberFormatInfo) numberFormat = (prov as NumberFormatInfo);
            
            if (Denominator == 0)
            {
                if (Numerator == 0) return numberFormat.NaNSymbol;
                else if (Numerator == 1) return numberFormat.PositiveInfinitySymbol;
                else if (Numerator == -1) return numberFormat.NegativeInfinitySymbol;
            }

            if (Numerator == 0)
                return "0";
            
            if (Denominator < 0)
            {
                Numerator *= -1;
                Denominator *= -1;
            }

            var num = Numerator;
            bool isNegative = false;
            if (num < 0)
            {
                num = -num;
                isNegative = true;
            }

            var stringResult = fracToString(num, Denominator, prov);
            if (isNegative)
                return numberFormat.NegativeSign + stringResult;
            return stringResult;
        }

        /// <summary> Converts the fraction to a decimal string. </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return ToString(null);
        }

        /// <summary> Compares two numbers. </summary>
        /// <param name="other"></param>
        /// <returns> True if they are equal. </returns>
        public bool Equals(BigFloat other)
        {
            return CompareTo(other) == 0;
        }

        /// <summary>
        /// Compares this bigfloat with another object.
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            if (obj is BigFloat)
                return Equals((BigFloat)obj);
            return base.Equals(obj);
        }

        /// <summary>
        /// Gets the hash code of this value.
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return Numerator.GetHashCode() ^ Denominator.GetHashCode();
        }

        /// <summary> Compares two numbers. </summary>
        /// <param name="other"></param>
        /// <returns>-1 if other is less, 1 if other is greater and 0 if other is equal to this.</returns>
        public int CompareTo(BigFloat other)
        {
            if (Denominator == 0)
            {
                if (Numerator == 0)
                    return -1;

                if (other.Denominator == 0)
                {
                    if (other.Numerator == 0) // NaN
                        return -1;
                    return Numerator.CompareTo(other.Numerator); //compare negiative/positive infinities.
                }
                return Numerator > 0 ? 1 : -1; // infinity
            }

            var a = Numerator * other.Denominator;
            var b = other.Numerator * Denominator;
            
            return a.CompareTo(b);
        }

        /// <summary>
        /// Converts obj before doing comparison using CompareTo. Throws an exception if obj cannot be compared to a BigFloat.
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int CompareTo(object obj)
        {
            if (obj == null)
                throw new ArgumentNullException("obj");
            switch (obj)
            {
                case double d: return CompareTo(new BigFloat(d));
                case short d: return CompareTo(new BigFloat(d));
                case int d: return CompareTo(new BigFloat(d));
                case float d: return CompareTo(new BigFloat(d));
                case decimal d: return CompareTo(new BigFloat(d));
                case uint d: return CompareTo(new BigFloat(d));
                case BigFloat d: return CompareTo(d);
                default:
                    throw new InvalidCastException(string.Format("Unable to compare BigFloat to {0}", obj.GetType()));
            }
        }

        /// <summary> Big float 1. </summary>
        public static readonly BigFloat One = new BigFloat(BigInteger.One, BigInteger.One);

        /// <summary> Supports parsing BigFloat without throwing an exception. Returns an exception in case something went wrong otherwise it will return a BigFloat.</summary>
        /// <param name="value"></param>
        /// <param name="format"></param>
        /// <returns></returns>
        internal static object Parse(string value, IFormatProvider format = null)
        {
            if (string.Equals(value, "infinity", StringComparison.OrdinalIgnoreCase))
                return Infinity;
            if (string.Equals(value, "-infinity", StringComparison.OrdinalIgnoreCase))
                return NegativeInfinity;
            if (string.Equals(value, "nan", StringComparison.OrdinalIgnoreCase))
                return NaN;
            if (value.Contains("/"))
            {
                // parse fractions: X/Y
                var splitted = value.Split('/');
                if (splitted.Length != 2)
                {
                    return new FormatException("value contains multiple '/'");
                }
                var numerator = BigInteger.Parse(splitted[0]);
                var denominator = BigInteger.Parse(splitted[1]);
                return new BigFloat(numerator, denominator);
            }

            var sep = getDigitSeparator(format);
            int index = 0;
            bool dotHit = false;
            bool exp = false;
            BigInteger sign = 1;
            BigFloat mantissa = 0;
            BigInteger denom = 1;
            BigInteger nomerator = 0;
            for (; index < value.Length; index++)
            {
                var chr = value[index];
                if (chr == '-' && nomerator == 0 && sign == 1)
                {
                    sign = -1;
                    continue;
                }
                if (chr == sep && !dotHit && !exp)
                {
                    dotHit = true;
                    continue;
                }
                if ((chr == 'e' || chr == 'E') && !exp)
                {
                    exp = true;
                    mantissa = new BigFloat(nomerator * sign, denom);
                    denom = 1;
                    nomerator = 0;
                    dotHit = false;
                    sign = 1;
                    continue;
                }
                if (char.IsWhiteSpace(chr)) continue;
                if ((chr == '+') && exp) continue;
                if (char.IsDigit(chr) == false)
                    return new FormatException("Format not supported.");
                if (dotHit)
                    denom *= 10;
                int v = (chr - '0');
                nomerator = nomerator * 10 + v;
            }
                
            if (exp)
            {
                //The scientific format "xEy" was detected, e.g 1.5e6
                if (nomerator > 1000)
                {   // Extremely large numbers will cause the application to stall
                    // the biggest number in .NET is double.Infinty: 1.7976931348623157E+308
                    // so 1E+1000 is probably an ok max limit.
                    throw new FormatException($"The value {value} is too huge or too precise to be presented as a number.");
                }

                var powerTerm = BigInteger.Pow(10, (int)nomerator);
                if (sign < 0)
                    return mantissa * new BigFloat(1, powerTerm);
                return mantissa * new BigFloat(powerTerm, 1);
            }
            return new BigFloat(nomerator * sign, denom);
        }

        /// <summary> Big float 0. </summary>
        public static readonly BigFloat Zero = new BigFloat(BigInteger.Zero, BigInteger.One);
        /// <summary> Big float Infinity. </summary>
        public static readonly BigFloat Infinity = new BigFloat(BigInteger.One, BigInteger.Zero);
        /// <summary> Big float negative infinity. </summary>
        public static readonly BigFloat NegativeInfinity = new BigFloat(BigInteger.MinusOne, BigInteger.Zero);
        /// <summary> Big float not a number. </summary>
        public static readonly BigFloat NaN = new BigFloat(BigInteger.Zero, BigInteger.Zero);

        /// <summary>
        /// Converts this value to a string.
        /// </summary>
        /// <param name="format"></param>
        /// <param name="formatProvider"></param>
        /// <returns></returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            return ToString(formatProvider);
        }
        static bool fastButImpreciseEnabled = false;
        /// <summary> Creates a BigFloat. </summary>
        /// <param name="value"></param>
        public BigFloat(double value) : this(value.ToString("R", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture)
        {
            if (fastButImpreciseEnabled)
            { 
                if (value == 0)
                {
                    Numerator = 0;
                    Denominator = 1;
                    return;
                }
                double tolerance = 1.0E-9;
                double orig = value;
                var bc = BigFloat.Zero;
                BigInteger frac = BigInteger.One;
                double frac2 = 1.0;
                while (true)
                {
                    if (Math.Abs(value / orig) < tolerance)
                        break;
                    double a = Math.Round(value);
                    value -= a;

                    var fc = new BigFloat((BigInteger)a, frac);
                    bc = bc + fc;
                    frac2 *= 1000;
                    value *= 1000.0;
                    orig *= 1000.0;
                    frac *= 1000;
                }

                this = bc.Normalize();
            }
        }

        public BigFloat(BigInteger v):this(v, BigInteger.One)
        {

        }

        public BigFloat(float value) : this(value.ToString("r", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture) { }

        public BigFloat(decimal value) : this(value.ToString("F9", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture)
        {
        }
        public BigFloat(string value, IFormatProvider format = null)
        {
            var result = Parse(value, format);
            if (result is BigFloat bf)
            {
                this = bf;
            }
            else throw (Exception)result;
        }

        private bool IsNan { get { return (Denominator == 0) && (Numerator == 0); } }
        private bool IsPosInf { get { return (Denominator == 0) && (Numerator == 1); } }
        private bool IsNegInf { get { return (Denominator == 0) && (Numerator == -1); } }

        public BigFloat(int value) : this(value, 1) { }
        public BigFloat(uint value) : this(value, 1) { }
        public BigFloat(short value) : this(value, 1) { }
        public BigFloat(long value) : this(value, 1) { }
        public static implicit operator BigFloat(double d)
        {
            return new BigFloat(d);
        }

        public static implicit operator BigFloat(long d)
        {
            return new BigFloat(d, 1);
        }

        public static implicit operator BigFloat(int d)
        {
            return new BigFloat(d, 1);
        }
        
        public static explicit operator int(BigFloat d)
        {
            return (int)d.Rounded();
        }

        public static explicit operator double(BigFloat d)
        {
            return ((double)d.Numerator) / ((double)d.Denominator);
        }

        public static bool operator ==(BigFloat a, BigFloat b)
        {
            if ((a.Denominator == 0) || (b.Denominator == 0))
            {
                if (a.IsNan || b.IsNan)
                    return false;
                else
                    return (a.Denominator == b.Denominator) && (a.Numerator == b.Numerator);
            }
            else
                return a.Equals(b);
        }

        public static bool operator !=(BigFloat a, BigFloat b)
        {
            if ((a.Denominator == 0) || (b.Denominator == 0))
            {
                if (a.IsNan || b.IsNan)
                    return true;
                else
                    return (a.Denominator != b.Denominator) || (a.Numerator != b.Numerator);
            }
            else
                return a.Equals(b) == false;
        }

        public static bool operator ==(BigFloat a, double b)
        {
            return a.Equals(b);
        }

        public static bool operator !=(BigFloat a, double b)
        {
            return a.Equals(b) == false;
        }

        public static bool operator >=(BigFloat a, BigFloat b)
        {
            if ((a.Denominator == 0) || (b.Denominator == 0))
            {
                if (a.IsNan || b.IsNan) return false;
                else if (a.IsNegInf) return b.IsNegInf;
                else if (b.IsPosInf) return a.IsPosInf;
                else return true;
            }
            else
                return a.CompareTo(b) >= 0;
        }

        public static bool operator <=(BigFloat a, BigFloat b)
        {
            if ((a.Denominator == 0) || (b.Denominator == 0))
            {
                if (a.IsNan || b.IsNan) return false;
                else if (a.IsPosInf) return b.IsPosInf;
                else if (b.IsNegInf) return a.IsNegInf;
                else return true;
            }
            else
                return a.CompareTo(b) <= 0;
        }

        public static bool operator >(BigFloat a, BigFloat b)
        {
            if ((a.Denominator == 0) || (b.Denominator == 0))
            {
                if (a.IsNan || b.IsNan)
                    return false;
                else if (a.IsPosInf) return !b.IsPosInf;
                else if (b.IsNegInf) return !a.IsNegInf;
                else
                    return false;
            }
            else
                return a.CompareTo(b) > 0;
        }

        public static bool operator <(BigFloat a, BigFloat b)
        {
            if ((a.Denominator == 0) || (b.Denominator == 0))
            {
                if (a.IsNan || b.IsNan) return false;
                else if (a.IsNegInf) return !b.IsNegInf;
                else if (b.IsPosInf) return !a.IsPosInf;
                else return false;
            }
            else
                return a.CompareTo(b) < 0;
        }
        
        public BigFloat Sign()
        {
            if (Numerator >= 0)
                return new BigFloat(1, 1);
            return new BigFloat(-1, 1);
        }

        public static BigFloat operator +(BigFloat a, BigFloat b)
        {
            if (a.IsNan || b.IsNan) return NaN;
            if (a.IsZero) return b;
            if (b.IsZero) return a;
            
            if (a.Denominator != b.Denominator)
            {
                var adenum = a.Denominator;

                a.Denominator *= b.Denominator;
                a.Numerator *= b.Denominator;

                b.Denominator *= adenum;
                b.Numerator *= adenum;
            }
            return new BigFloat(a.Numerator + b.Numerator, b.Denominator).Normalize();
        }

        public bool IsZero => Numerator.IsZero;

        public static BigFloat operator -(BigFloat a, BigFloat b)
        {
            if (a.IsNan || b.IsNan) return NaN;
            if (b.IsZero) return a;
            if (a.IsZero) return new BigFloat(-b.Numerator, b.Denominator);

            if (a.Denominator != b.Denominator)
            {
                var adenum = a.Denominator;

                a.Denominator *= b.Denominator;
                a.Numerator *= b.Denominator;

                b.Denominator *= adenum;
                b.Numerator *= adenum;
            }

            if (a.Numerator == b.Numerator)
            {
                if (a.IsPosInf || b.IsNegInf) return NaN;
                return Zero;
            }

            return new BigFloat(a.Numerator - b.Numerator, b.Denominator).Normalize();
        }
        public static BigFloat operator /(BigFloat a, BigFloat b)
        {
            if (a.IsNan || b.IsNan) return NaN;
            else if (a.IsNegInf)
            {
                if (b.IsPosInf || b.IsNegInf) return NaN;
                else if (b < 0) return Infinity;
            }
            else if (a.IsPosInf)
            {
                if (b.IsPosInf || b.IsNegInf) return NaN;
                else if (b < 0) return NegativeInfinity;
            }
            else if (b == One) return a;
            else if (a.IsZero)
            {
                if (b.IsZero) return NaN;
                return Zero;
            }
            else if (b.IsZero)
            {
                return a.Numerator > 0 ? Infinity : NegativeInfinity;
            }

            return new BigFloat(a.Numerator * b.Denominator, b.Numerator * a.Denominator).Normalize();
        }

        public static BigFloat operator *(BigFloat a, BigFloat b)
        {
            if (a.IsNan || b.IsNan) return NaN;
            if (a.IsZero)
            {
                if (b.IsPosInf || b.IsNegInf) return NaN;
                return Zero;
            }

            if (b.IsZero)
            {
                if (a.IsPosInf || a.IsNegInf) return NaN;
                return Zero;
            }

            return new BigFloat(a.Numerator * b.Numerator, a.Denominator * b.Denominator).Normalize();
        }

        public BigFloat Abs()
        {
            return new BigFloat(Numerator * Numerator.Sign, Denominator * Denominator.Sign);
        }

        public BigInteger Rounded()
        {
            if (Denominator == 0) return int.MinValue;
            if (Numerator == 0) return 0;
            if (Denominator == 1) return Numerator;

            return Numerator / Denominator;
        }

        public BigFloat Round()
        {
            if (IsNan || IsNegInf || IsPosInf) return this;

            return new BigFloat(Rounded(), 1);
        }
        
        public static BigFloat Convert(object y, IFormatProvider prov = null)
        {
            switch (y)
            {
                case BigFloat x: return x;
                case double x: return new BigFloat(x);
                case float x: return new BigFloat(x);
                case decimal x: return new BigFloat(x);
                case int x: return new BigFloat(x);
                case long x: return new BigFloat(x);
                case string x: return new BigFloat(x, prov);
                default: return new BigFloat((long)System.Convert.ChangeType(y, typeof(long)));
            }
        }

        public object ConvertTo(Type t)
        {
            Normalize();

            if (t == typeof(BigFloat))
                return this;
            if (t == typeof(double))
                return (((double)Numerator) / ((double)Denominator));
            if (t == typeof(float))
                return (float)((double)((double)Numerator) / ((double)Denominator));
            if (t == typeof(decimal))
                return ((decimal)Numerator) / ((decimal)Denominator);
            if (t == typeof(int))
                return (int)(Numerator / Denominator);
            if (t == typeof(long))
                return (long)(Numerator / Denominator);
            if (t == typeof(string))
                return ToString();
            if (typeof(BigFloat).DescendsTo(t))
                return this;
            return System.Convert.ChangeType(ConvertTo(typeof(long)), t);
        }

        public static BigFloat operator -(BigFloat a)
        {
            return new BigFloat(-a.Numerator, a.Denominator);
        }
    }

    /// <summary> Converter for OpenTAP arbitrary precision number types. </summary>
    class BigFloatConverter : TypeConverter
    {
        /// <summary> returns  true if it can convert from </summary>
        /// <param name="context"></param>
        /// <param name="sourceType"></param>
        /// <returns></returns>
        public override bool CanConvertFrom(ITypeDescriptorContext context,
           Type sourceType)
        {
            if (sourceType.IsNumeric() || sourceType == typeof(string) || sourceType == typeof(BigFloat))
                return true;
            return base.CanConvertFrom(context, sourceType);
        }

        /// <summary>
        /// Converts from an object to a number.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="culture"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public override object ConvertFrom(ITypeDescriptorContext context,
           CultureInfo culture, object value)
        {
            return BigFloat.Convert(value);
        }

        /// <summary>
        /// Converts to a number.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="culture"></param>
        /// <param name="value"></param>
        /// <param name="destinationType"></param>
        /// <returns></returns>
        public override object ConvertTo(ITypeDescriptorContext context,
           CultureInfo culture, object value, Type destinationType)
        {
            return ((BigFloat)value).ConvertTo(destinationType);
        }
    }
}