//            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.Globalization;
using System;

namespace OpenTap
{
    /// <summary>
    /// Takes care of printing and parsing time spans like '1 s' or '15.3 ms'. Supports seconds, milliseconds, microseconds and nanoseconds.
    /// </summary>
    struct ShortTimeSpan
    {
       
        public enum UnitKind{
            Seconds,
            Milliseconds,
            Microseconds,
            Nanoseconds
        };

        UnitKind unit;

        public UnitKind Unit => unit;

        public double Value { get; set; }

        public double Seconds
        {
            get { return Value * Scale; }
        }
        
        public static ShortTimeSpan FromSeconds(double seconds)
        {

            var s = seconds;
            UnitKind unit = UnitKind.Seconds;
            
            if (s < 1)
            {
                s = seconds * 1e3;
                unit = UnitKind.Milliseconds;
                if (s < 1)
                {
                    s = seconds * 1e6;
                    unit = UnitKind.Microseconds;

                    if (s < 1)
                    {
                        s = seconds * 1e9;
                        unit = UnitKind.Nanoseconds;
                        if (s < 1) // treat < 0 ns as 0 s.
                            return default(ShortTimeSpan);
                    }
                }
            }
            
            return new ShortTimeSpan { unit = unit, Value = Math.Round(s, 3) };
        }

        /// <summary>
        /// For formating of timespans longer than 1 minute like "1 d 1 h 14m" instead of "90840 s"
        /// </summary>
        /// <param name="timeSpan"></param>
        /// <returns></returns>
        public static string LongTimeSpanFormat(TimeSpan timeSpan)
        {
            string result = "";
            if (timeSpan.TotalMinutes < 1)
            {   
                var (timeString, unit) = FromSeconds(timeSpan.TotalSeconds).ToStringParts();

                return FormatTimeStringParts(timeString, unit);
            }
            if (timeSpan.Days > 0)
            {
                result += $"{timeSpan.Days} d ";

            } 
            if (timeSpan.Hours > 0)
            {
                result += $"{timeSpan.Hours} h ";
            }

            if (timeSpan.Minutes > 0)
            {
                result += $"{timeSpan.Minutes} m ";
            }

            if (timeSpan.Seconds > 0)
            {
                result += $"{timeSpan.Seconds} s ";
            }

            return result.Trim();
        }

        private static string FormatTimeStringParts(string timeString, string unit)
        {
            var formattedString = $"{timeString,5:0} {unit,-4}";
            return formattedString;
        }

        public static ShortTimeSpan FromString(string str)
        {
            str = str.Trim();
            UnitKind scale = UnitKind.Seconds;
            if (str.EndsWith("ms"))
            {
                scale = UnitKind.Milliseconds;
            }
            else if (str.EndsWith("μs") || str.EndsWith("us")) // support mu symbol for forward compatibility use
            {
                scale = UnitKind.Microseconds;
            }
            else if (str.EndsWith("ns"))
            {
                scale = UnitKind.Nanoseconds;
            }
            else if (str.EndsWith("s"))
            {

            }

            int index = 0;
            for (; index < str.Length; index++)
            {
                if (char.IsNumber(str[index]) || str[index] == '.')
                    continue;
                else
                    break;
            }
            str = str.Substring(0, index);
            var val = double.Parse(str, NumberStyles.Any, CultureInfo.InvariantCulture);
            return new ShortTimeSpan { Value = val, unit = scale };
        }

        static string getUnitString(UnitKind unit)
        {
            switch (unit)
            {
                case UnitKind.Microseconds:
                    return "us"; // "μs" support this notation at a later time.
                case UnitKind.Milliseconds:
                    return "ms";
                case UnitKind.Nanoseconds:
                    return "ns";
                default:
                    return "s";
            }
        }

        public double Scale
        {
            get
            {
                switch (unit)
                {
                    case UnitKind.Milliseconds:
                        return 1e-3;
                    case UnitKind.Microseconds:
                        return 1e-6;
                    case UnitKind.Nanoseconds:
                        return 1e-9;
                    default:
                        return 1;
                }
            }
        }
        
        public override string ToString()
        {
            if (Value < 10)
                return string.Format(CultureInfo.InvariantCulture, "{0:0.00} {1}", Math.Floor(Value * 100) * 0.01, getUnitString(Unit));
            else if (Value < 100)
                return string.Format(CultureInfo.InvariantCulture, "{0:0.0} {1}", Math.Round(Value * 10) * 0.1, getUnitString(Unit));
            else
                return string.Format(CultureInfo.InvariantCulture, "{0} {1}", Math.Floor(Value), getUnitString(Unit));
        }

        /// <summary> To avoid generating extra garbage during formatting, this can be used with StringBuilder. </summary>
        /// <param name="output"></param>
        public void ToString(System.Text.StringBuilder output)
        {
            if (Value < 0.01)
            {
                output.Append("0 ns");
                return;
            };
            if (Value < 10)
                output.Append((Math.Floor(Value * 100) * 0.01).ToString("0.00", CultureInfo.InvariantCulture));
            else if (Value < 100)
                output.Append((Math.Floor(Value * 10) * 0.1).ToString("0.0", CultureInfo.InvariantCulture));
            else
                output.Append(Math.Floor(Value).ToString(CultureInfo.InvariantCulture));
            output.Append(' ');
            output.Append(getUnitString(Unit));
        }

        public (string, string) ToStringParts()
        {
            if (Value < 10)
                return (string.Format(CultureInfo.InvariantCulture, "{0:0.00}", Math.Floor(Value * 100) * 0.01), getUnitString(Unit));
            else if (Value < 100)
                return (string.Format(CultureInfo.InvariantCulture, "{0:0.0}", Math.Floor(Value * 10) * 0.1), getUnitString(Unit));
            else
                return (string.Format(CultureInfo.InvariantCulture, "{0:0}", Math.Floor(Value)), getUnitString(Unit));
        }
    }
}