TimeSpan.cs

using System.Collections.Generic;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Functions.DateAndTime
{
    public class TimeSpan : FunctionMultiVariate
    {
        public TimeSpan(ScriptNode String, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { String }, argumentTypes1Scalar, Start, Length, Expression)
        {
        }
 
        public TimeSpan(ScriptNode Hours, ScriptNode Minutes, ScriptNode Seconds, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Hours, Minutes, Seconds }, argumentTypes3Scalar, Start, Length, Expression)
        {
        }
 
        public TimeSpan(ScriptNode Days, ScriptNode Hours, ScriptNode Minutes, ScriptNode Seconds, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Days, Hours, Minutes, Seconds }, argumentTypes4Scalar, Start, Length, Expression)
        {
        }
 
        public TimeSpan(ScriptNode Days, ScriptNode Hours, ScriptNode Minutes, ScriptNode Seconds, ScriptNode MSeconds, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Days, Hours, Minutes, Seconds, MSeconds }, argumentTypes5Scalar, Start, Length, Expression)
        {
        }
 
        public override string FunctionName => nameof(TimeSpan);
 
        public override string[] DefaultArgumentNames
        {
            get { return new string[] { "Hour", "Minute", "Second" }; }
        }
 
        public override IElement Evaluate(IElement[] Arguments, Variables Variables)
        {
            int i, c = Arguments.Length;
 
            if (c == 1)
            {
                object Obj = Arguments[0].AssociatedObjectValue;
 
                if (Obj is System.DateTime TP)
                    return new ObjectValue(TP.TimeOfDay);
                else if (Obj is System.DateTimeOffset TPO)
                    return new ObjectValue(TPO.TimeOfDay);
                else if (Obj is TimeSpan)
                    return Arguments[0];
 
                string s = Obj?.ToString() ?? string.Empty;
 
                if (TryParse(s, out System.TimeSpan TS))
                    return new ObjectValue(TS);
                else
                    throw new ScriptRuntimeException("Unable to parse TimeSpan value: " + s, this);
            }
 
            double[] d = new double[c];
            DoubleNumber n;
 
            for (i = 0; i < c; i++)
            {
                n = Arguments[i] as DoubleNumber;
                if (n is null)
                    throw new ScriptRuntimeException("Expected number arguments.", this);
 
                d[i] = n.Value;
            }
 
            switch (c)
            {
                case 3:
                    return new ObjectValue(new System.TimeSpan((int)d[0], (int)d[1], (int)d[2]));
 
                case 4:
                    return new ObjectValue(new System.TimeSpan((int)d[0], (int)d[1], (int)d[2], (int)d[3]));
 
                case 5:
                    return new ObjectValue(new System.TimeSpan((int)d[0], (int)d[1], (int)d[2], (int)d[3], (int)d[4]));
 
                default:
                    throw new ScriptRuntimeException("Invalid number of parameters.", this);
            }
        }
 
        public static bool TryParse(string s, out System.TimeSpan TS)
        {
            s = s.Trim();
 
            int c = s.Length;
            int Pos = 0;
            bool Sign = false;
 
            if (c == 0)
            {
                TS = default;
                return false;
            }
 
            if (s[0] == '+')
                Pos++;
            else if (s[0] == '-')
            {
                Sign = true;
                Pos++;
            }
 
            if (!DateTime.TryParseInt(s, ref Pos, '.', out int Days, out _) || Days < System.TimeSpan.MinValue.Days || Days > System.TimeSpan.MaxValue.Days)
                Days = 0;
            else if (Pos >= c)
            {
                TS = new System.TimeSpan(Days, 0, 0, 0);
                if (Sign)
                    TS = -TS;
                return true;
            }
 
            if (!DateTime.TryParseInt(s, ref Pos, ':', out int Hour, out _) || Hour < 0 || Hour > 23)
            {
                TS = default;
                return false;
            }
            else if (Pos >= c)
            {
                TS = new System.TimeSpan(Days, Hour, 0, 0);
                if (Sign)
                    TS = -TS;
                return true;
            }
 
            if (!DateTime.TryParseInt(s, ref Pos, ':', out int Minute, out _) || Minute < 0 || Minute > 59)
            {
                TS = default;
                return false;
            }
            else if (Pos >= c)
            {
                TS = new System.TimeSpan(Days, Hour, Minute, 0);
                if (Sign)
                    TS = -TS;
                return true;
            }
 
            if (!DateTime.TryParseInt(s, ref Pos, '.', out int Second, out _) || Second < 0 || Second > 59)
            {
                TS = default;
                return false;
            }
            else if (Pos >= c)
            {
                TS = new System.TimeSpan(Days, Hour, Minute, Second);
                if (Sign)
                    TS = -TS;
                return true;
            }
 
            if (!DateTime.TryParseInt(s, ref Pos, '\x0', out int MilliSecond, out int NrDigits) || Pos < c)
            {
                TS = default;
                return false;
            }
 
            if (NrDigits > 3)
            {
                while (NrDigits > 4)
                {
                    MilliSecond /= 10;
                    NrDigits--;
                }
 
                MilliSecond += 5;
                MilliSecond /= 10;
            }
 
            TS = new System.TimeSpan(Days, Hour, Minute, Second, MilliSecond);
            if (Sign)
                TS = -TS;
            return true;
        }
 
        public override PatternMatchResult PatternMatch(IElement CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            object Obj = CheckAgainst.AssociatedObjectValue;
 
            if (!(Obj is System.TimeSpan TS))
            {
                if (Obj is double d)
                    TS = new System.TimeSpan((long)d);
                else
                {
                    string s = CheckAgainst.AssociatedObjectValue?.ToString() ?? string.Empty;
 
                    if (!System.TimeSpan.TryParse(s, out TS))
                    {
                        if (long.TryParse(s, out long Ticks))
                            TS = new System.TimeSpan(Ticks);
                        else
                            return PatternMatchResult.NoMatch;
                    }
                }
            }
 
            switch (this.Arguments.Length)
            {
                case 1:
                    return this.Arguments[0].PatternMatch(new ObjectValue(TS), AlreadyFound);
 
                case 3:
                    PatternMatchResult Result = this.Arguments[0].PatternMatch(new DoubleNumber(TS.Hours), AlreadyFound);
                    if (Result != PatternMatchResult.Match)
                        return Result;
 
                    Result = this.Arguments[1].PatternMatch(new DoubleNumber(TS.Minutes), AlreadyFound);
                    if (Result != PatternMatchResult.Match)
                        return Result;
 
                    return this.Arguments[2].PatternMatch(new DoubleNumber(TS.Seconds), AlreadyFound);
 
                case 4:
                    Result = this.Arguments[0].PatternMatch(new DoubleNumber(TS.Days), AlreadyFound);
                    if (Result != PatternMatchResult.Match)
                        return Result;
 
                    Result = this.Arguments[1].PatternMatch(new DoubleNumber(TS.Hours), AlreadyFound);
                    if (Result != PatternMatchResult.Match)
                        return Result;
 
                    Result = this.Arguments[2].PatternMatch(new DoubleNumber(TS.Minutes), AlreadyFound);
                    if (Result != PatternMatchResult.Match)
                        return Result;
 
                    return this.Arguments[3].PatternMatch(new DoubleNumber(TS.Seconds), AlreadyFound);
 
                case 5:
                    Result = this.Arguments[0].PatternMatch(new DoubleNumber(TS.Days), AlreadyFound);
                    if (Result != PatternMatchResult.Match)
                        return Result;
 
                    Result = this.Arguments[1].PatternMatch(new DoubleNumber(TS.Hours), AlreadyFound);
                    if (Result != PatternMatchResult.Match)
                        return Result;
 
                    Result = this.Arguments[2].PatternMatch(new DoubleNumber(TS.Minutes), AlreadyFound);
                    if (Result != PatternMatchResult.Match)
                        return Result;
 
                    Result = this.Arguments[3].PatternMatch(new DoubleNumber(TS.Seconds), AlreadyFound);
                    if (Result != PatternMatchResult.Match)
                        return Result;
 
                    return this.Arguments[4].PatternMatch(new DoubleNumber(TS.Milliseconds), AlreadyFound);
 
                default:
                    return PatternMatchResult.NoMatch;
            }
        }
 
    }
}