//            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.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Numerics;
using System.Text;

namespace OpenTap
{
    class Range : IEnumerable<BigFloat>
    {
        public readonly BigFloat Start;
        public readonly BigFloat Stop;
        public readonly BigFloat Step;

        public IEnumerator<BigFloat> GetEnumerator()
        {
            var start = Start;
            var stop = Stop;
            var step = Step;

            if (Start == Stop)
            { // A a range of 0 elements will be created otherwise. So return Start.
                yield return Start;
                yield break;
            }
            // This calculation is based on linear extrapolation that includes the end point 
            // on the condition that it's within double.epsilon
            var approximate_steps = ((stop - start) / step).Abs();

            // Cancel the last step if it's the calculated spot is more than double.epsilon further away.
            BigInteger steps = approximate_steps.Rounded();
            for (BigInteger i = 0; i <= steps; i++)
            {
                yield return new BigFloat(i) * step + start;
            }
        }

        public Range(BigFloat start, BigFloat stop)
        {
            Start = start;
            Stop = stop;
            Step = (Stop - Start).Sign();
            CheckRange();
        }

        public Range(BigFloat start, BigFloat stop, BigFloat step)
        {
            Start = start;
            Stop = stop;
            Step = step;
            CheckRange();
        }

        public void CheckRange()
        {
            if (Stop == Start) return; // Math.Sign(0) == 0.
            if (Step == 0 || (Stop - Start).Sign() != Step.Sign())
                throw new Exception("Infinite range not supported.");
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public override string ToString()
        {
            return ToString(null);
        }

        public string ToString(Func<object, string> conv)
        {
            conv = conv ?? ((v) => v.ToString());

            if (Step == new BigFloat(1.0) || Step == new BigFloat(-1.0))
            {
                return string.Format("{0} : {1}", conv(Start), conv(Stop));
            }
            return string.Format("{0} : {1} : {2}", conv(Start), conv(Step), conv(Stop));
        }
    }

    class UnitFormatter
    {
        static BigFloat peta = 1000000000000000L;
        static BigFloat tera = 1000000000000L;
        static BigFloat giga = 1000000000L;
        static BigFloat mega = 1000000;
        static BigFloat kilo = 1000;
        static BigFloat one = 1;
        static BigFloat mili = kilo.Invert();
        static BigFloat micro = mega.Invert();
        static BigFloat nano = giga.Invert();
        static BigFloat pico = tera.Invert();
        static BigFloat femto = peta.Invert();


        static BigFloat engineeringPrefixLevel(char l)
        {
            switch (l)
            {
                case 'T': return tera;
                case 'G': return giga;
                case 'M': return mega;
                case 'k': return kilo;
                case ' ': return one;
                case 'm': return mili;
                case 'u': return micro;
                case 'n': return nano;
                case 'p': return pico;
                case 'f': return femto;
                default: throw new Exception("Invalid engineering prefix");
            }
        }
        static char[] levels = { 'T', 'G', 'M', 'k', ' ', 'm', 'u', 'n', 'p', 'f' };

        static char findLevel(BigFloat value)
        {
            foreach (char level in levels)
            {
                var eng = engineeringPrefixLevel(level);
                if (value >= eng || value <= -eng)
                {
                    return level;
                }
            }
            return ' ';
        }

        public static void Format(StringBuilder sb, BigFloat value, bool prefix, string unit, string format, CultureInfo culture,
            bool compact = false)
        {
            char level = prefix ? findLevel(value) : ' ';
            BigFloat scaling = engineeringPrefixLevel(level);
            BigFloat post_scale = value / scaling;

            if (string.IsNullOrEmpty(format))
                post_scale.AppendTo(sb, culture);
            else
            {
                if (format.StartsWith("x", StringComparison.OrdinalIgnoreCase))
                    sb.Append(((long)post_scale.Rounded()).ToString(format, culture));
                else if (format.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
                    sb.Append("0x" + ((long)post_scale.Rounded()).ToString(format.Substring(1), culture));
                else
                {
                    try
                    {
                        sb.Append(((decimal)post_scale.ConvertTo(typeof(decimal))).ToString(format, culture));
                    }
                    catch
                    {
                        post_scale.AppendTo(sb, culture);
                    }
                }
            }

            if (level == ' ' && string.IsNullOrEmpty(unit))
            {
                return;
            }

            string space = compact ? "" : " ";
            sb.Append(space);
            if (level != ' ')
                sb.Append(level);
            if(unit != null)
                sb.Append(unit);
        }

        public static string Format(BigFloat value, bool prefix, string unit, string format, CultureInfo culture, bool compact = false)
        {
            char level = prefix ? findLevel(value) : ' ';
            BigFloat scaling = engineeringPrefixLevel(level);
            BigFloat post_scale = value / scaling;
            string final_string;

            if (string.IsNullOrEmpty(format))
                final_string = post_scale.ToString("R", culture);
            else
            {
                if (format.StartsWith("x", StringComparison.OrdinalIgnoreCase))
                    final_string = ((long)post_scale.Rounded()).ToString(format, culture);
                else if (format.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
                    final_string = "0x" + ((long)post_scale.Rounded()).ToString(format.Substring(1), culture);
                else
                {
                    try
                    {
                        final_string = ((decimal)post_scale.ConvertTo(typeof(decimal))).ToString(format, culture);
                    }
                    catch
                    {
                        final_string = post_scale.ToString(format, culture);
                    }
                }
            }

            if (level == ' ' && string.IsNullOrEmpty(unit))
            {
                return final_string;
            }

            string space = compact ? "" : " ";

            if (level == ' ')
                return string.Format("{0}{2}{1}", final_string, unit, space);
            else
                return string.Format("{0}{3}{1}{2}", final_string, level, unit ?? "", space);
        }
        static object parse(string str, string unit, string format, CultureInfo culture)
        {
            if (str == null)
                return new ArgumentNullException("str");
            if (unit == null)
                return new ArgumentNullException("unit");
            if (format == null)
                return new ArgumentNullException("format");
            if (culture == null)
                return new ArgumentNullException("culture");

            str = str.Trim();

            bool IsHex =
                (str.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ||
                str.StartsWith("-0x", StringComparison.OrdinalIgnoreCase));
            int HexSkip = 2;

            if ((!IsHex) &&
               (format.StartsWith("x", StringComparison.OrdinalIgnoreCase)))
            {
                IsHex = true;
                HexSkip = 0;
            }

            if (unit.Length > 0 && str.EndsWith(unit, StringComparison.OrdinalIgnoreCase))
                str = str.Remove(str.Length - unit.Length);
            str = str.TrimEnd();
            if (str.Length == 0)
            {
                return new FormatException("Invalid format");
            }

            char prefix = str[str.Length - 1];
            BigFloat multiplier = 1.0;
            if (levels.Contains(prefix))
            {
                // Handle case of "femto" unit
                if (!(IsHex && (prefix == 'f') && !str.EndsWith(" f", StringComparison.Ordinal)))
                {
                    multiplier = engineeringPrefixLevel(prefix);
                    if (str[str.Length - 1] == prefix)
                        str = str.Substring(0, str.Length - 1).TrimEnd();
                }
            }

            if (IsHex && str.StartsWith("-", StringComparison.OrdinalIgnoreCase))
                return new BigFloat(-Int64.Parse(str.Substring(HexSkip + 1).ToUpper(), NumberStyles.HexNumber, culture)) * multiplier;
            else if (IsHex)
                return new BigFloat(BigInteger.Parse("0" + str.Substring(HexSkip).ToUpper(), NumberStyles.HexNumber, culture)) * multiplier;

            if (str.StartsWith("0b", StringComparison.OrdinalIgnoreCase) || str.StartsWith("-0b", StringComparison.OrdinalIgnoreCase))
            {
                string bits = "";
                if (str.StartsWith("-0b", StringComparison.OrdinalIgnoreCase))
                {
                    multiplier = -multiplier;
                    bits = str.Substring(2);
                }
                else
                {
                    bits = str.Substring(2);
                }

                BigInteger v = 0;
                foreach (var bit in bits)
                {
                    if (bit == '1')
                    {
                        v = v << 1 | 1;
                    }
                    else if (bit == '0')
                    {
                        v = v << 1;
                    }
                    else if (char.IsWhiteSpace(bit))
                        continue;
                    else
                    {
                        return new FormatException("Invalid binary format.");
                    }
                }
                return new BigFloat(v) * multiplier;
            }
            var r = BigFloat.Parse(str, culture);
            if (r is BigFloat bf)
                return bf * multiplier;
            return r;
        }
        public static BigFloat Parse(string str, string unit, string format, CultureInfo culture)
        {
            var result = parse(str, unit, format, culture);
            if (result is BigFloat bf)
                return bf;
            else throw (Exception)result;
        }

        public static bool TryParse(string str, string unit, string format, CultureInfo culture, out BigFloat bf)
        {
            var result = parse(str, unit, format, culture);
            if (result is BigFloat _bf)
            {
                bf = _bf;
                return true;
            }
            bf = default(BigFloat);

            return false;

        }
    }

    /// <summary>
    /// A number of combined number sequences.
    /// </summary>
    public interface ICombinedNumberSequence : IEnumerable
    {
        /// <summary>
        /// Inner values representing the sequence.
        /// </summary>
        List<IEnumerable<double>> Sequences { get; }

        /// <summary>
        /// Casts the number sequence to a specific type. Should be a numeric type, e.g. typeof(float).
        /// </summary>
        /// <param name="elementType"></param>
        /// <returns></returns>
        ICombinedNumberSequence CastTo(Type elementType);
    }

    /// <summary>
    /// Generic number sequence type.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface ICombinedNumberSequence<T> : IEnumerable<T>, ICombinedNumberSequence
    {
        /// <summary>
        /// Casts this to a new number sequence type.
        /// </summary>
        /// <typeparam name="T2"></typeparam>
        /// <returns></returns>
        ICombinedNumberSequence<T2> CastTo<T2>();
    }

    /// <summary>
    /// Extensions for ICombinedNumberSequence.
    /// </summary>
    public static class ICombinedNumberSequenceExtension
    {
        /// <summary> Casts one type ICombinedNumberSequence to another. </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="seq"></param>
        /// <returns></returns>
        public static ICombinedNumberSequence<T> CastTo<T>(this ICombinedNumberSequence seq)
        {
            return (ICombinedNumberSequence<T>)seq.CastTo(typeof(T));
        }
    }

    interface _ICombinedNumberSequence
    {
        List<IEnumerable<BigFloat>> Sequences { get; set; }
    }

    class CombinedNumberSequences<T> : IEnumerable<T>, ICombinedNumberSequence<T>, _ICombinedNumberSequence
    {
        public List<IEnumerable<BigFloat>> Sequences { get; set; }

        List<IEnumerable<double>> ICombinedNumberSequence.Sequences { get {return Sequences.Select(x => x.Select(y => (double)y.ConvertTo(typeof(double)))).ToList(); } }

        public CombinedNumberSequences(List<IEnumerable<BigFloat>> sequences)
        {
            this.Sequences = sequences;
        }

        IEnumerable<T> getValues()
        {
            foreach (var seq in Sequences)
            {
                foreach (BigFloat val in seq)
                {
                    yield return (T)val.ConvertTo(typeof(T));
                }
            }
        }

        public IEnumerator<T> GetEnumerator()
        {
            return getValues().GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return getValues().GetEnumerator();
        }

        public ICombinedNumberSequence<T1> CastTo<T1>()
        {
            return new CombinedNumberSequences<T1>(Sequences);
        }

        public ICombinedNumberSequence CastTo(Type elemType)
        {
            return (ICombinedNumberSequence)Activator.CreateInstance(typeof(CombinedNumberSequences<>).MakeGenericType(elemType), Sequences);
        }
    }

    /// <summary>
    /// Parser / back parser for numbers and sequences of numbers.
    /// </summary>
    public class NumberFormatter
    {
        CultureInfo culture;
        string separator;
        /// <summary>
        /// Argument to string.Format.
        /// </summary>
        public string Format = "";
        /// <summary>
        /// Unit of the numbers (e.g. 'Hz').
        /// </summary>
        public string Unit = "";
        /// <summary>
        /// Boolean setting. When true, parse number into prefixes. For example, '10000 Hz' becomes '10 kHz'. 
        /// </summary>
        public bool UsePrefix = false;
        /// <summary>
        /// Pre-scales numbers before converting.
        /// </summary>
        public double PreScaling = 1.0;
        /// <summary>
        /// Boolean setting. When true, numbers are parsed back into ranges. When false, separate values as used as their raw representation. 
        /// </summary>
        public bool UseRanges = true;

        /// <summary>
        /// Print using compact representation.
        /// </summary>
        public bool IsCompact = false;

        /// <summary> </summary>
        /// <param name="culture"> The culture used to parse/write numbers.</param>
        public NumberFormatter(CultureInfo culture)
        {
            if (culture == null)
                throw new ArgumentNullException("culture");
            this.culture = culture;
            separator = culture.NumberFormat.NumberGroupSeparator + " ";
        }

        /// <summary>
        /// Creates a number parser based on a UnitAttribute.
        /// </summary>
        /// <param name="culture"></param>
        /// <param name="unit"></param>
        public NumberFormatter(CultureInfo culture, UnitAttribute unit) : this(culture)
        {
            if (unit != null)
            {
                Format = unit.StringFormat;
                Unit = unit.Unit;
                UsePrefix = unit.UseEngineeringPrefix;
                PreScaling = unit.PreScaling;
                UseRanges = unit.UseRanges;
            }
        }

        const bool enableFeatureFractions = false;
        BigFloat parseNumber(string trimmed)
        {
            // support fractions e.g 1/3 disabled because its hard to convert back from 0.333333... to 1/3, so this gives problems with formatting.
            if (enableFeatureFractions && trimmed.Contains('/'))
                return trimmed.Split('/').Select(part => parseNumber(part.Trim())).Aggregate((x, y) => x * PreScaling / y);
            return UnitFormatter.Parse(trimmed, Unit ?? "", Format, culture) * PreScaling;
        }

        bool tryParseNumber(string trimmed, out BigFloat val)
        {
            return UnitFormatter.TryParse(trimmed, Unit ?? "", Format, culture, out val);
        }
        
        void parseBackNumber(BigFloat number, StringBuilder sb)
        {
            if (PreScaling != 1.0)
                number = number / PreScaling;
            UnitFormatter.Format(sb, number , UsePrefix, Unit ?? "", Format, culture, IsCompact);
        }

        string parseBackNumber(BigFloat number)
        {
            return UnitFormatter.Format(number / PreScaling, UsePrefix, Unit ?? "", Format, culture, IsCompact);
        }

        void parseBackRange(BigFloat Start, BigFloat Step, BigFloat Stop, StringBuilder sb)
        {
            parseBackNumber(Start, sb);
            if (Step != PreScaling)
            {
                sb.Append(" : ");
                parseBackNumber(Step, sb);
            }
            sb.Append(" : ");
            parseBackNumber(Stop, sb);
        }
        
        string parseBackRange(Range rng)
        {
            if (rng.Step == PreScaling)
            {
                return string.Format("{0} : {1}", parseBackNumber(rng.Start), parseBackNumber(rng.Stop));
            }
            return string.Format("{0} : {1} : {2}", parseBackNumber(rng.Start), parseBackNumber(rng.Step), parseBackNumber(rng.Stop));
        }

        Range parseRange(string formatted)
        {
            var parts = formatted.Split(':').Select(s => s.Trim());
            var rangeitems = parts.Select(parseNumber).ToArray();
            Range result = null;
            if (rangeitems.Length == 3)
            {
                result = new Range(rangeitems[0], rangeitems[2], rangeitems[1]);
            }
            else
            if (rangeitems.Length == 2)
            {
                result = new Range(rangeitems[0], rangeitems[1], PreScaling * (rangeitems[1] - rangeitems[0]).Sign());
            }
            else
            {
                throw new FormatException(string.Format("Unable to parse Range from {0}", formatted));
            }
            result.CheckRange();
            return result;
        }

        /// <summary>
        /// Parses a string to a sequence of doubles.
        /// supports ranges, sequences, units and prefixes.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public ICombinedNumberSequence<double> Parse(string value)
        {
            if (value == null)
                throw new ArgumentNullException("value");
            string separator = culture.NumberFormat.NumberGroupSeparator;
            var splits = value.Split(new string[] { separator }, StringSplitOptions.RemoveEmptyEntries);
            List<IEnumerable<BigFloat>> parts = new List<IEnumerable<BigFloat>>();
            foreach (var split in splits)
            {
                var trimmed = split.Trim();
                if (trimmed.Contains(':'))
                {
                    Range rng = parseRange(trimmed);
                    parts.Add(rng);
                }
                else
                {
                    var result = parseNumber(trimmed);
                    if (parts.Count == 0 || parts[parts.Count - 1] is Range)
                    {
                        parts.Add(new List<BigFloat> { result });
                    }
                    else
                    {
                        ((IList<BigFloat>)parts[parts.Count - 1]).Add(result);
                    }
                }
            }
            List<IEnumerable<BigFloat>> parts2 = new List<IEnumerable<BigFloat>>();

            if (UseRanges)
            {
                // this for loop 'compresses' the parts by trying to reuse and create Range objects.
                for (int i = 0; i < parts.Count; i++)
                {
                    var item = parts[i];
                    if (item is Range)
                    {
                        parts2.Add(item);
                        continue;
                    }
                    var vals = item as IList<BigFloat>;
                    bool reuse_last = false;
                    BigFloat start = 0, stop = 0, step = 0;
                    int nitems = 0;
                    var last = parts2.LastOrDefault() as Range;
                    if (last != null)
                    {
                        start = last.Start;
                        stop = last.Stop;
                        step = last.Step;
                        nitems = (int)((((stop - start) / step) + 0.5).Rounded() + 1);
                        reuse_last = true;
                    }

                    Action submit = () =>
                    {
                        if (nitems == 0)
                            return;
                        if (reuse_last)
                        {
                            parts2[parts2.Count - 1] = new Range(start, stop, step);
                        }
                        else
                        {
                            if (nitems > 2)
                            {
                                if (step == 0)
                                {
                                    BigFloat[] values = new BigFloat[nitems];
                                    for (int j = 0; j < nitems; j++)
                                        values[j] = start;
                                    parts2.Add(values);
                                }
                                else
                                {
                                    parts2.Add(new Range(start, stop, step));
                                }
                            }
                            else if (nitems == 2)
                            {
                                parts2.Add(new BigFloat[] { start, stop });
                            }
                            else
                            {
                                parts2.Add(new BigFloat[] { start });
                            }
                        }
                        nitems = 0;
                        step = 0;
                    };

                    foreach (var val in vals)
                    {
                        start:
                        if (nitems == 0)
                        {
                            start = val;
                            nitems = 1;
                            continue;
                        }
                        if (nitems == 1)
                        {
                            stop = val;
                            step = stop - start;
                            nitems = 2;
                            continue;
                        }

                        BigFloat nextval;
                        if (step == 0)
                            nextval = stop; // Avoid NaN nextval.
                        else
                            nextval = start + (step * (1 + ((stop - start) / step).Round()));

                        if ((val - nextval) == 0)
                        {
                            stop = val;
                            nitems += 1;
                        }
                        else
                        {
                            submit();
                            reuse_last = false;
                            goto start; // run again with val as start.
                        }
                    }
                    submit();

                }
            }
            else
                parts2 = parts.Select(x => x.ToList() as IEnumerable<BigFloat>).ToList();
            return new CombinedNumberSequences<BigFloat>(parts2).CastTo<double>();

        }

        void pushSeq(StringBuilder sb, BigFloat val)
        {
            if (sb.Length != 0)
                sb.Append(separator);
            parseBackNumber(val, sb);
        }
        
        void pushSeq(StringBuilder sb, IList<BigFloat> seq, BigFloat step)
        {
            if (seq.Count > 2 && step.IsZero == false)
            {
                if (sb.Length != 0)
                    sb.Append(separator);
                parseBackRange(seq[0], step, seq[seq.Count - 1], sb);
            }
            else
            {
                foreach (var val in seq)
                {
                    if (sb.Length != 0)
                        sb.Append(separator);
                    parseBackNumber(val, sb);
                }
            }
        }

        /// <summary>
        /// Parses a number back to a string.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public string FormatNumber(object value)
        {
            if (value == null)
                return "";
            return parseBackNumber(BigFloat.Convert(value));
        }

        /// <summary>
        /// Parses a single number from a string.
        /// </summary>
        /// <param name="str"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public object ParseNumber(string str, Type t)
        {
            if (str == null) throw new ArgumentNullException("str");
            if (t == null) throw new ArgumentNullException("t");
            try
            {
                
                return parseNumber(str).ConvertTo(t);
            }
            catch (OverflowException)
            {
                throw new FormatException(string.Format("Unable to parse '{0}' to a {1}", str, t.Name));
            }
        }

        /// <summary>
        /// Try to parse a single number from a string.
        /// </summary>
        /// <param name="str">the string to parse.</param>
        /// <param name="t">the return type of value. must be numeric. </param>
        /// <param name="val">resulting value. Null if parsing failed.</param>
        /// <returns></returns>
        public bool TryParseNumber(string str, Type t, out object val)
        {
            if(tryParseNumber(str, out BigFloat val2))
            {
                val = val2.ConvertTo(t);
                return true;
            }
            val = null;
            return false;
        }

        /// <summary>
        /// Parses a sequence of numbers back into a string.
        /// </summary>
        /// <param name="values"></param>
        /// <returns></returns>
        public string FormatRange(IEnumerable values)
        {
            if (values == null)
                throw new ArgumentNullException("values");
            { // Check if values is a ICombinedNumberSequence. 
              // If so, it can be parsed back faster. (without iterating through all the ranges).
                var seqs = values as _ICombinedNumberSequence;
                if (seqs != null)
                {
                    StringBuilder sb = StringBuilderCache.GetStringBuilder();
                    foreach (var subseq in seqs.Sequences)
                    {
                        var range = subseq as Range;
                        if (range != null)
                        {
                            if (sb.Length != 0)
                                sb.Append(separator);
                            sb.Append(parseBackRange(range));
                        }
                        else
                        {
                            foreach (var val in subseq)
                            {
                                if (sb.Length != 0)
                                    sb.Append(separator);
                                sb.Append(parseBackNumber(val));
                            }
                        }
                    }
                    return sb.ToString();
                }
            }
            if (UseRanges)
            { // Parse the slow way.
                StringBuilder sb = StringBuilderCache.GetStringBuilder();
                List<BigFloat> sequence = new List<BigFloat>();
                BigFloat seq_step = 0;
                foreach (var _val in values)
                {
                    var val = BigFloat.Convert(_val);
                    if (sequence.Count < 2)
                    {
                        sequence.Add(val);
                    }
                    else
                    {
                        seq_step = sequence[1] - sequence[0];
                        var nextVal = sequence[0] + seq_step * (1 + ((sequence.Last() - sequence[0]) / seq_step).Round());
                        if ((nextVal - val) == BigFloat.Zero)
                        {
                            sequence.Add(val);
                        }
                        else
                        {
                            if (sequence.Count == 2)
                            {
                                pushSeq(sb, sequence[0]);
                                sequence.RemoveAt(0);
                            }
                            else
                            {
                                pushSeq(sb, sequence, seq_step);
                                sequence.Clear();
                            }

                            sequence.Add(val);
                        }
                    }
                }
                pushSeq(sb, sequence, seq_step);
                return sb.ToString();
            }
            if (!UsePrefix)
            {
                // this ca be done really fast since we dont have to use BigFloat.
                var sb = StringBuilderCache.GetStringBuilder();
                foreach (var _val in values)
                {
                    if (sb.Length != 0)
                        sb.Append(separator);
                    switch (_val)
                    {
                        case float i:
                            sb.Append(i.ToString("R", culture));
                            break;
                        case decimal i: 
                            sb.Append(i.ToString("G", culture));
                            break;
                        case double i: 
                            sb.Append(i.ToString("R17", culture));
                            break;
                        default:
                            sb.Append(_val);
                            break;
                    }

                    if (string.IsNullOrEmpty(Unit) == false)
                    {
                        sb.Append(" ");
                        sb.Append(Unit);
                    }
                }

                return sb.ToString();
            }
            
            {
                StringBuilder sb = StringBuilderCache.GetStringBuilder();
                foreach (var _val in values)
                {
                    var val = BigFloat.Convert(_val);

                    if (sb.Length != 0)
                        sb.Append(separator);
                    parseBackNumber(val, sb);
                }
                return sb.ToString();
            }
        }
    }
}