//            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.Linq;
using System.Reflection;
using System.ComponentModel;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Text;
using System.Threading;
using OpenTap.Translation;

//**** WARNING ****//
// This file is used in many projects(link existing), but only with internal protection.
// NEVER insert a public class here or things will break due to multiple definitions of the same class.
// Bugs introduced here will cause bugs in other projects too, so be careful.
// **

namespace OpenTap
{
    /// <summary>
    /// Class to ease the use of reflection.
    /// </summary>
    internal static class ReflectionHelper
    {
        /// <summary>Returns true if 'type' and 'basetype' are equal. </summary> 
        /// <param name="type"></param>
        /// <param name="basetype"></param>
        /// <returns></returns>
        public static bool IsA(this ITypeData type, Type basetype)
        {
            if (type is TypeData cst)
                return cst.Type == basetype;
            return false;
        }
        
        public static T GetBaseType<T>(this ITypeData type) where T: ITypeData
        {
            var typeIterator = type;
            while (typeIterator != null)
            {
                if (typeIterator is TypeData)
                    break;
                if (typeIterator is T t2)
                    return t2;
                typeIterator = typeIterator.BaseType;
            }
            return default;
        }
        
        /// <summary> Really fast direct descendant test. This checks for reference equality of the type or a base type, and 'baseType'.
        /// Given these constraints are met, this can be 6x faster than DescendsTo, but should only be used in special cases. </summary>
        public static bool DirectInheritsFrom(this ITypeData type, ITypeData baseType)
        {
            do
            {
                if(ReferenceEquals(type, baseType)) return true;
                type = type.BaseType;
            } while (type != null);
            return false;
        }

        public static TypeData AsTypeData(this ITypeData type)
        {
            do
            {
                if (type is TypeData td)
                    return td;
                type = type?.BaseType;
            } while (type != null);
            return null;
        } 

        static Dictionary<MemberInfo, DisplayAttribute> displayLookup = new Dictionary<MemberInfo, DisplayAttribute>(1024);
        static object displayLookupLock = new object();

        public static DisplayAttribute GetDisplayAttribute(this MemberInfo type)
        {
            lock (displayLookupLock)
            {
                if (!displayLookup.ContainsKey(type))
                {
                    DisplayAttribute attr;
                    try
                    {
                        attr = type.GetAttribute<DisplayAttribute>();
                    }
                    catch
                    {   // This might happen for outdated plugins where an Attribute type ceased to exist.
                        attr = null;
                    }

                    if (attr == null)
                    {
                        attr = new DisplayAttribute(type.Name, null, Order: -10000, Collapsed: false);
                    }

                    displayLookup[type] = attr;
                }

                return displayLookup[type];
            }
        }

        /// <summary>
        /// Parses a DisplayName into a group:name pair.
        /// </summary>
        /// <param name="displayName"></param>
        /// <param name="group"></param>
        /// <returns></returns>
        internal static string ParseDisplayname(string displayName, out string group)
        {
            group = "";
            var parts = displayName.Trim().TrimStart('-').Split('\\');

            if (parts.Length == 1) return displayName;
            else if (parts.Length >= 2)
            {
                group = parts[0].Trim();
                return parts.Last().Trim();
            }
            else
                return displayName.Trim();
        }
       
        static object[] getAttributes(MemberInfo mem)
        {
            try
            {
                return mem.GetCustomAttributes(true);
            }
            catch
            {
                return Array.Empty<object>();
            }
        }

        static readonly ConditionalWeakTable<MemberInfo, object[]> attrslookup = new ConditionalWeakTable<MemberInfo, object[]>();
        public static object[] GetAllCustomAttributes(this MemberInfo prop)
        {
            return attrslookup.GetValue(prop, getAttributes);
        }
        
        static object[] getAttributesNoInherit(MemberInfo mem)
        {
            try
            {
                return mem.GetCustomAttributes(false);
            }
            catch
            {
                return Array.Empty<object>();
            }
        }
        static readonly ConditionalWeakTable<MemberInfo, object[]> attrslookupNoInherit = new ConditionalWeakTable<MemberInfo, object[]>();
        public static object[] GetAllCustomAttributes(this MemberInfo prop, bool inherit)
        {
            if(!inherit)
                return attrslookupNoInherit.GetValue(prop, getAttributesNoInherit);
            return GetAllCustomAttributes(prop);
        }

        /// <summary>
        /// Gets the custom attributes. Both type and property attributes. Also inherited attributes.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="prop"></param>
        /// <returns></returns>
        public static T[] GetCustomAttributes<T>(this MemberInfo prop) where T : Attribute
        {
            // This method impacts GUI, serialization and even test plan execution times.
            // it needs to be as fast as possible.

            // Avoid allocation when there is nothing of type T in the attributes
            var array = GetAllCustomAttributes(prop);
            int cnt = 0;
            foreach (var attr in array)
            {
                if (attr is T)
                    cnt++;
            }

            if (cnt == 0)
                return Array.Empty<T>(); // This avoids allocation of empty arrays.
            T[] result = new T[cnt];

            cnt = 0;
            foreach (var attr in array)
            {
                if (attr is T a)
                {
                    result[cnt] = a;
                    cnt++;
                }
            }
            return result;
        }

        /// <summary>
        /// Gets the first or default of the custom attributes for this member. Both type and property attributes also inherited attributes.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="prop"></param>
        /// <returns></returns>
        public static T GetFirstOrDefaultCustomAttribute<T>(this MemberInfo prop) where T : Attribute
        {
            foreach (var attr in GetAllCustomAttributes(prop))
                if (attr is T a)
                    return a;
            return null;
        }

        /// <summary>
        /// Gets the first or default of the custom attributes for this property. Both type and property attributes also inherited attributes.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="prop"></param>
        /// <returns></returns>
        public static T GetAttribute<T>(this MemberInfo prop) where T : Attribute
        {
            return GetFirstOrDefaultCustomAttribute<T>(prop);
        }

        /// <summary>
        /// return whether the property has a given attribute T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="prop"></param>
        /// <returns></returns>
        public static bool HasAttribute<T>(this MemberInfo prop) where T : Attribute
        {
            return prop.IsDefined(typeof(T), true);
        }
        /// <summary>
        /// Return whether the attribute has the given attribute T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static bool HasAttribute<T>(this Type t) where T : Attribute
        {
            return t.IsDefined(typeof(T), true);
        }

        /// <summary>
        /// Returns true if a MemberInfo is Browsable.
        /// </summary>
        /// <param name="m"></param>
        /// <returns></returns>
        public static bool IsBrowsable(this MemberInfo m)
        {
            var b = m.GetAttribute<BrowsableAttribute>();
            if (b == null) return true;
            return b.Browsable;
        }



        /// <summary>
        /// Check whether a type 'descends' to otherType or "can be otherType".
        /// </summary>
        /// <param name="t"></param>
        /// <param name="otherType"></param>
        /// <returns></returns>
        public static bool DescendsTo(this Type t, Type otherType)
        {
            if (t == otherType)
                return true;
            if (otherType.IsGenericTypeDefinition)
            {   // In the case otherType is constructed from typeof(X<>), not typeof(X<T>).

                if (otherType.IsInterface)
                {
                    var interfaces = t.GetInterfaces();
                    foreach (var iface in interfaces)
                    {
                        if (iface.IsGenericType)
                        {
                            if (iface.GetGenericTypeDefinition() == otherType)
                                return true;
                        }   
                    }
                    if (t.IsInterface)
                    {
                        if (t.IsGenericType)
                        {
                            if (t.GetGenericTypeDefinition() == otherType)
                                return true;
                        }
                    }
                }
                else
                {
                    Type super = t;
                    while (super != typeof(object) && super != null /*if not a class*/)
                    {
                        if (super.IsGenericType && super.GetGenericTypeDefinition() == otherType)
                            return true;
                        super = super.BaseType;
                    }
                }
            }
            
            return otherType.IsAssignableFrom(t);
        }

        /// <summary>
        /// returns whether t has a given interface T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static bool HasInterface<T>(this Type t)
        {
            return typeof(T).IsAssignableFrom(t);
        }

        /// <summary>
        /// Returns true if a type is numeric.
        /// </summary>
        public static bool IsNumeric(this Type t)
        {
            if (t.IsEnum)
                return false;
            switch (Type.GetTypeCode(t))
            {
                case TypeCode.Byte:
                case TypeCode.SByte:
                case TypeCode.UInt16:
                case TypeCode.UInt32:
                case TypeCode.UInt64:
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.Decimal:
                case TypeCode.Double:
                case TypeCode.Single:
                    return true;
                default:
                    return false;
            }
        }

        /// <summary> Returns true if a type is numeric. </summary>
        public static bool IsNumeric(this ITypeData t)
        {
            return t.AsTypeData()?.Type.IsNumeric() == true;
        }
        
        /// <summary> Returns true if a type is a C# primitive. </summary>
        public static bool IsPrimitive(this ITypeData t)
        {
            return t.AsTypeData()?.Type.IsPrimitive ?? false;
        }

        /// <summary> Creates an instance of t with no constructor arguments. </summary>
        public static object CreateInstance(this Type t, params object[] args) => Activator.CreateInstance(t, args);

        /// <summary> Creates an instance of type t. If an error occurs it returns null and prints an error message. </summary>
        public static object CreateInstanceSafe(this ITypeData t, params object[] args)
        {
            try
            {
                return t.CreateInstance(args);
            }
            catch(Exception e)
            {
                var log = Log.CreateSource("Reflection");
                log.Error($"Cannot create instance of {t.Name}: '{e.Message}'");
                log.Debug(e);
            }
            return null;
        }

        /// <summary>
        /// If Type is a collection of items, get the element type.
        /// </summary>
        /// <param name="enumType"></param>
        /// <returns></returns>
        static public Type GetEnumerableElementType(this Type enumType)
        {
            if (enumType.IsArray)
                return enumType.GetElementType();
            if (enumType.IsGenericTypeDefinition)
                return null;
            try
            {
                // check if it *has* the interface
                var ienumInterface = enumType.GetInterface(typeof(IEnumerable<>).Name);
                if (ienumInterface != null)
                    return ienumInterface.GetGenericArguments().FirstOrDefault();
            }
            catch (AmbiguousMatchException)
            {
                // the type implements multiple different IEnumerable<> interfaces.
                // this is an odd case that is not commonly seen.
            }

            // check if it *is* the interface.
            if(enumType.IsInterface && enumType.IsGenericType && enumType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
            {
                return enumType.GetGenericArguments().FirstOrDefault();
            }

            return null;
        }

        static readonly Dictionary<Type, PropertyInfo[]> propslookup = new Dictionary<Type, PropertyInfo[]>(1024);
        static PropertyInfo[] getPropertiesTap(Type t)
        {
            lock (propslookup)
            {
                if (propslookup.ContainsKey(t) == false)
                {
                    try
                    {
                        propslookup[t] = t.GetProperties(BindingFlags.Public | BindingFlags.Instance);
                    }
                    catch
                    {
                        propslookup[t] = Array.Empty<PropertyInfo>();
                    }
                }
                return propslookup[t];
            }
        }

        public static bool ContainsMember(this IParameterMemberData p, (object Source, IMemberData Member) item)
        {
            return p.ParameterizedMembers.Contains(item);
        }
            

        /// <summary> Extracts properties from a Type that are public and not static. Default GetProperties() also returns static properties. </summary>
        public static PropertyInfo[] GetPropertiesTap(this Type type)
        {
            return getPropertiesTap(type);
        }

        static readonly Dictionary<Type, MethodInfo[]> propslookup2 = new Dictionary<Type, MethodInfo[]>(1024);
        static MethodInfo[] getMethodsTap(Type t)
        {
            lock (propslookup2)
            {
                if (propslookup2.ContainsKey(t) == false)
                {
                    try
                    {
                        propslookup2[t] = t.GetMethods();
                    }
                    catch
                    {
                        propslookup2[t] = Array.Empty<MethodInfo>();
                    }
                }
                return propslookup2[t];
            }
        }

        /// <summary> Extracts properties from a Type that are public and not static. Default GetProperties() also returns static properties. </summary>
        public static MethodInfo[] GetMethodsTap(this Type type)
        {
            return getMethodsTap(type);
        }

        public static bool MethodOverridden(this Type t, Type baseType, string methodName)
        {
            var m1 = baseType.GetMethod(methodName).MethodHandle.Value;
            var m2 = t.GetMethod(methodName).MethodHandle.Value;
            return m1 != m2;
        } 

        /// <summary> Get the base C# type of a given type. </summary>
        internal static T As<T>(this ITypeData type) where T: ITypeData
        {
            for(;type != null; type = type.BaseType)
                if (type is T td)
                    return td;
            return default;
        }
        
        public static void GetAttributes<T>(this IReflectionData mem, System.Collections.IList outList)
        {
            foreach (var item in mem.Attributes)
            {
                if (item is T x)
                    outList.Add(x);
            }
        }
    }
    
    internal class Memorizer
    {
        /// <summary>
        /// Enumerates how cyclic invokes can be handled.
        /// </summary>
        public enum CyclicInvokeMode
        {
            /// <summary>
            /// Specifies that an exception should be thrown.
            /// </summary>
            ThrowException,
            /// <summary>
            /// Specifies that default(ResultT) should be returned.
            /// </summary>
            ReturnDefaultValue
        }
    }

    internal interface IMemorizer<ArgT, ResultT>
    {
        ResultT Invoke(ArgT arg);
        void InvalidateAll();

    }

    /// <summary>
    /// Convenient when some memorizer optimizations can be done. 
    /// Includes functionality for decay time and max number of elements.
    /// It assumes that the same ArgT will always result in the same ResultT.
    /// </summary>
    /// <typeparam name="ArgT"></typeparam>
    /// <typeparam name="ResultT"></typeparam>
    /// <typeparam name="MemorizerKey"></typeparam>
    internal class Memorizer<ArgT, ResultT, MemorizerKey> : Memorizer, IMemorizer<ArgT, ResultT>
    {
        /// <summary>
        /// Used for locking the invokation of a specific MemorizerKey. 
        /// This makes it possible to call Invoke in parallel and avoid recalculating the same value multiple times.
        /// </summary>
        class LockObject
        {
            public bool IsLocked;
        }
        
        /// <summary> If a certain time passes a result should be removed. By default, never. </summary>
        public TimeSpan SoftSizeDecayTime = TimeSpan.MaxValue;
        protected Func<ArgT, MemorizerKey> getKey;
        protected Func<ArgT, ResultT> getData = argt => (ResultT)(object)argt;
        
        readonly Dictionary<MemorizerKey, DateTime> lastUse = new Dictionary<MemorizerKey, DateTime>();
        readonly Dictionary<MemorizerKey, ResultT> memorizerTable = new Dictionary<MemorizerKey, ResultT>();
        readonly Dictionary<MemorizerKey, LockObject> locks = new Dictionary<MemorizerKey, LockObject>();

        /// <summary> Can be used to create a validation key for each key in the memorizer.
        /// Validation keys are used for checking if the memory is up to date or if it should be refreshed. </summary>
        public Func<MemorizerKey, object> Validator { get; set; } = null;
        readonly Dictionary<MemorizerKey, object> validatorData = new Dictionary<MemorizerKey, object>();
        
        /// <summary>
        /// Specifies how to handle situations where an Invoke(x) triggers another Invoke(x) in the same thread. 
        /// Since this might cause infinite recursion, it is not allowed. By default an exception is thrown.
        /// </summary>
        public CyclicInvokeMode CylicInvokeResponse = CyclicInvokeMode.ThrowException;

        public Nullable<ulong> MaxNumberOfElements { get; set; }

        public Memorizer(Func<ArgT, MemorizerKey> getKey = null,
            Func<ArgT, ResultT> extractData = null)
        {
            if (extractData != null)
                getData = extractData;
            this.getKey = getKey;
        }

        /// <summary>
        /// Forces manual update of constraints.
        /// </summary>
        public void CheckConstraints()
        {
            while (checkSizeConstraints() == Status.Changed) { }
        }

        enum Status
        {
            Changed,
            Unchanged
        }

        Status checkSizeConstraints()
        {
            if (SoftSizeDecayTime < TimeSpan.MaxValue || MaxNumberOfElements.HasValue
                && (ulong) memorizerTable.Count > MaxNumberOfElements.Value)
            {
                lock (memorizerTable)
                {

                    var removeKey = lastUse.Keys.FindMin(key2 => lastUse[key2]);
                    if (removeKey != null)
                    {
                        if (SoftSizeDecayTime < DateTime.UtcNow - lastUse[removeKey])
                        {
                            lastUse.Remove(removeKey);
                            memorizerTable.Remove(removeKey);
                            return Status.Changed;
                        }
                        else if (MaxNumberOfElements.HasValue
                                 && (ulong) memorizerTable.Count > MaxNumberOfElements.Value)
                        {
                            lastUse.Remove(removeKey);
                            memorizerTable.Remove(removeKey);
                            return Status.Changed;
                        }
                    }
                }
            }

            return Status.Unchanged;
        }
        
        MemorizerKey invokeGetKey(ArgT arg)
        {
            return getKey == null ? (MemorizerKey)(object)arg : getKey(arg);
        }

        public virtual ResultT OnCyclicCallDetected(ArgT key)
        {
            throw new Exception("Cyclic memorizer invoke detected.");
        }

        public ResultT this[ArgT arg] => Invoke(arg);

        public ResultT Invoke(ArgT arg)
        {
            var key = invokeGetKey(arg);
            if(Validator != null){
                var obj = Validator(key);
                lock (memorizerTable)
                {
                    if (validatorData.TryGetValue(key, out object value))
                    {
                        if (false == Equals(value, obj))
                        {
                            Invalidate(arg);
                            validatorData[key] = obj;
                        }   
                    }else
                    {
                        validatorData[key] = obj;
                    }
                }
            }
            
            LockObject lockObj;
            lock (memorizerTable)
            {
                lastUse[key] = DateTime.UtcNow;
                if (!locks.TryGetValue(key, out lockObj))
                {
                    lockObj = new LockObject();
                    locks[key] = lockObj;
                }
            }
            lock (lockObj)
            {
                if (lockObj.IsLocked)
                {   // Avoid running into a StackOverflowException.

                    if (CylicInvokeResponse == CyclicInvokeMode.ThrowException)
                        return OnCyclicCallDetected(arg);
                    return default(ResultT);
                }
                try
                {
                    lockObj.IsLocked = true;
                    lock (memorizerTable)
                    {
                        if (memorizerTable.TryGetValue(key, out ResultT value))
                            return value;
                    }
                    ResultT o = getData(arg);
                    lock (memorizerTable)
                    {
                        memorizerTable[key] = o;
                        checkSizeConstraints();
                    }
                    return o;
                }
                finally
                {
                    lockObj.IsLocked = false;
                }
            }
        }

        public ResultT GetCached(ArgT arg)
        {
            ResultT o = default(ResultT);
            var key = invokeGetKey(arg);

            lock (memorizerTable)
            {
                if (!memorizerTable.TryGetValue(key, out o))
                    return default(ResultT);
                lastUse[key] = DateTime.UtcNow;;
            }
            return o;
        }

        public void Add(ArgT arg, ResultT value)
        {
            var key = invokeGetKey(arg);

            lock (memorizerTable)
            {
                lastUse[key] = DateTime.UtcNow;
                memorizerTable[key] = value;
                checkSizeConstraints();
            }
        }

        public void Invalidate(ArgT value)
        {
            var key = invokeGetKey(value);

            lock (memorizerTable)
            {
                memorizerTable.Remove(key);
                lastUse.Remove(key);
                validatorData.Remove(key);
            }
        }

        /// <summary>
        /// Invalidate the keys where f returns true. This is being done while
        /// the memorizer is locked, so race conditions are avoided.
        /// </summary>
        /// <param name="predicate"></param>
        public void InvalidateWhere(Func<MemorizerKey, ResultT, bool> predicate)
        {
            lock (memorizerTable)
            {
                List<MemorizerKey> keys = null;
                foreach(var item in memorizerTable)
                {
                    if(predicate(item.Key, item.Value))
                    {
                        if(keys == null)
                        {
                            keys = new List<MemorizerKey>();
                        }
                        keys.Add(item.Key);
                    }
                }
                if(keys != null)
                {
                    foreach(var k in keys)
                    {
                        memorizerTable.Remove(k);
                        lastUse.Remove(k);
                    }
                }
            }
        }

        public List<ResultT> GetResults()
        {
            lock (memorizerTable)
            {
                return memorizerTable.Values.ToList();
            }
        }


        public void InvalidateAll()
        {
            lock (memorizerTable)
            {
                memorizerTable.Clear();
                lastUse.Clear();
                validatorData.Clear();
            }
        }
    }

    internal class Memorizer<ArgT, ResultT> : Memorizer<ArgT, ResultT, ArgT>
    {
        public Memorizer(Func<ArgT, ResultT> func) : base(extractData: func)
        {
        }
    }


    static class Utils
    {
        static readonly char[] padding = { '=' };

        public static string Base64UrlEncode(byte[] bytes)
        {
            return Convert.ToBase64String(bytes)
                .TrimEnd(padding).Replace('+', '-')
                .Replace('/', '_');
        }

        public static IEnumerable<(int, T)> WithIndex<T>(this IEnumerable<T> collection)
        {
            return collection.Select((ele, index) => (index, ele));
        }

        /// <summary>
        /// Thread-safe and lock free value exchange. valueGen depends on the current value.
        /// </summary>
        /// <param name="outPlace"> Where to place the value</param>
        /// <param name="valueGen"> Function generating a value based on the current value. </param>
        /// <typeparam name="T"> The type of object. </typeparam>
        public static void InterlockedSwap<T>(ref T outPlace, Func<T> valueGen) where T : class
        {
            while (true)
            {
                // safely add a new item to the list using the compare-and-swap atomic operation.
                var currentValue = outPlace;
                var nextValue = valueGen();

                if (Interlocked.CompareExchange(ref outPlace, nextValue, currentValue) == currentValue)
                {
                    break;
                }
            }
        }


#if DEBUG
        public static readonly bool IsDebugBuild = true;
#else
        public static readonly bool IsDebugBuild = false;
#endif

        /// <summary> Swaps two variables </summary>
        public static void Swap<T>(ref T a, ref T b) => (a, b) = (b, a);

        /// <summary> Do nothing. </summary>
        public static void Noop()
        {
        }

        /// <summary>
        /// Returns the element for which selector returns the max value.
        /// if IEnumerable is empty, it returns default(T) multiplier gives the direction to search.
        /// </summary>
        static T FindExtreme<T, C>(this IEnumerable<T> sequence, Func<T, C> selector, int multiplier)
            where C : IComparable
        {
            var e = sequence.GetEnumerator();
            if (!e.MoveNext())
                return default(T);

            T selected = e.Current;
            C max = selector(selected);

            while (e.MoveNext())
            {
                var obj = e.Current;
                C comparable = selector(obj);
                if (comparable.CompareTo(max) * multiplier > 0)
                {
                    selected = obj;
                    max = comparable;
                }
            }

            return selected;
        }


        /// <summary> Returns the element for which selector returns the max value. if IEnumerable is empty, it returns default(T). </summary>
        public static T FindMax<T, C>(this IEnumerable<T> ienumerable, Func<T, C> selector) where C : IComparable
        {
            return FindExtreme(ienumerable, selector, 1);
        }

        /// <summary>
        /// Returns the element for which selector returns the minimum value.
        /// if IEnumerable is empty, it returns default(T).
        /// </summary>
        public static T FindMin<T, C>(this IEnumerable<T> ienumerable, Func<T, C> selector) where C : IComparable
        {
            return FindExtreme(ienumerable, selector, -1);
        }

        /// <summary>
        /// Skips last N items.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="n">n last items to skip.</param>
        /// <returns></returns>
        public static IEnumerable<T> SkipLastN<T>(this IEnumerable<T> source, int n)
        {
            var list = source.ToList();
            if ((list.Count - n) > 0)
                return list.Take(list.Count - n);
            else
                return Enumerable.Empty<T>();
        }


        /// <summary>
        /// Removes items of source matching a given predicate.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="pred"></param>
        public static void RemoveIf<T>(this IList<T> source, Predicate<T> pred)
        {
            if (source is List<T> lst)
            {
                lst.RemoveAll(pred);
                return;
            }

            for (int i = source.Count - 1; i >= 0; i--)
            {
                if (pred(source[i]))
                {
                    source.RemoveAt(i);
                }
            }
        }

        /// <summary>
        /// Removes items of source matching a given predicate.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="pred"></param>
        public static void RemoveIf(this IList source, Predicate<object> pred)
        {

            for (int i = source.Count - 1; i >= 0; i--)
            {
                if (pred(source[i]))
                {
                    source.RemoveAt(i);
                }
            }
        }

        private static void flattenHeirarchy<T>(IEnumerable<T> lst, Func<T, IEnumerable<T>> lookup, IList<T> result,
            HashSet<T> found)
        {
            foreach (var item in lst)
            {
                if (found != null)
                {
                    if (found.Contains(item))
                        continue;
                    found.Add(item);
                }

                result.Add(item);
                var sublist = lookup(item);
                if (sublist != null)
                    flattenHeirarchy(sublist, lookup, result, found);
            }
        }

        /// <summary>
        /// Flattens a recursive IEnumerable.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="lst"></param>
        /// <param name="lookup">Returns a list of the next level of elements. The returned value is allowed to be null and will in this case be treated like an empty list.</param>
        /// <param name="distinct">True if only one of each element should be inserted in the list.</param>
        /// <param name="buffer">Buffer to use instead of creating a new list to store the values. This can be used to avoid allocation.</param>
        /// <returns></returns>
        public static List<T> FlattenHeirarchy<T>(IEnumerable<T> lst, Func<T, IEnumerable<T>> lookup,
            bool distinct = false, List<T> buffer = null)
        {
            if (buffer != null)
                buffer.Clear();
            else
                buffer = new List<T>();
            flattenHeirarchy(lst, lookup, buffer, distinct ? new HashSet<T>() : null);
            return buffer;
        }

        public static void FlattenHeirarchyInto<T>(IEnumerable<T> lst, Func<T, IEnumerable<T>> lookup, ISet<T> set)
        {
            foreach (var item in lst)
            {
                if (set.Add(item))
                {
                    var sublist = lookup(item);
                    if (sublist != null)
                        FlattenHeirarchyInto(sublist, lookup, set);
                }
            }
        }

        public static void ForEach<T>(this IEnumerable<T> source, Action<T> func)
        {
            foreach (var item in source)
            {
                func(item);
            }
        }

        /// <summary>
        /// Appends a range of elements to an IEnumerable.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="newObjects"></param>
        /// <returns></returns>
        public static IEnumerable<T> Append<T>(this IEnumerable<T> source, params T[] newObjects)
        {
            return source.Concat(newObjects);
        }

        /// <summary>  First index where the result of predicate function is true. </summary>
        public static int IndexWhen<T>(this IEnumerable<T> source, Func<T, bool> pred)
        {
            int idx = 0;
            foreach (var item in source)
            {
                if (pred(item))
                {
                    return idx;
                }

                idx++;
            }

            return -1;
        }

        /// <summary>
        /// Returns true if the generic IEnumerable is empty
        /// </summary>
        /// <param name="enu"></param>
        /// <returns></returns>
        public static bool IsEnumerableEmpty(this IEnumerable enu)
        {
            var e = enu.GetEnumerator();
            bool empty = e.MoveNext() == false;
            (e as IDisposable)?.Dispose();
            return empty;
        }

        /// <summary>
        /// Returns true if the source is longer than count elements.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="count"></param>
        /// <returns></returns>
        public static bool IsLongerThan<T>(this IEnumerable<T> source, long count)
        {
            foreach (var _ in source)
                if (--count < 0)
                    return true;
            return false;
        }

        /// <summary>
        /// Creates a HashSet from an IEnumerable.
        /// </summary>
        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> source)
        {
            return new HashSet<T>(source);
        }

        /// <summary>
        /// Creates a HashSet from an IEnumerable, with a specialized comparer.
        /// </summary>
        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> source, IEqualityComparer<T> comparer)
        {
            return new HashSet<T>(source, comparer);
        }

        /// <summary>
        /// The opposite of Where.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="selector"></param>
        /// <returns></returns>
        public static IEnumerable<T> Except<T>(this IEnumerable<T> source, Func<T, bool> selector)
        {
            foreach (var x in source)
                if (selector(x) == false)
                    yield return x;
        }

        /// <summary> As 'Select' but skipping null values.
        /// Short hand for/more efficient version of 'Select(f).Where(x => x != null)' </summary>
        /// <param name="source"></param>
        /// <param name="f"></param>
        /// <typeparam name="T1"></typeparam>
        /// <typeparam name="T2"></typeparam>
        /// <returns></returns>
        public static IEnumerable<T2> SelectValues<T1, T2>(this IEnumerable<T1> source, Func<T1, T2> f)
        {
            foreach (var x in source)
            {
                var value = f(x);
                if (value != null)
                    yield return value;
            }
        }

        /// <summary> As 'Select and FirstOrDefault' but skipping null values.
        /// Short hand for/more efficient version of 'Select(f).Where(x => x != null).FirstOrDefault()'
        /// </summary>
        public static T2 FirstNonDefault<T1, T2>(this IEnumerable<T1> source, Func<T1, T2> selector)
        {
            foreach (var x in source)
            {
                var value = selector(x);
                if (Equals(value, default(T2)) == false)
                    return value;
            }

            return default(T2);
        }

        /// <summary>
        /// Merged a dictionary into another, overwriting colliding keys.
        /// </summary>
        /// <typeparam name="T1"></typeparam>
        /// <typeparam name="T2"></typeparam>
        /// <param name="srcDict"></param>
        /// <param name="dstDict"></param>
        public static void MergeInto<T1, T2>(this Dictionary<T1, T2> srcDict, Dictionary<T1, T2> dstDict)
        {
            foreach (var kv in srcDict)
            {
                dstDict[kv.Key] = kv.Value;
            }
        }

        struct OnceLogToken
        {
            public object Token;
            public TraceSource Log;
        }

        static HashSet<OnceLogToken> logOnceTokens = new HashSet<OnceLogToken>();

        /// <summary>
        /// Avoids spamming the log with errors that 
        /// should only be shown once by memorizing token and TraceSource. 
        /// </summary>
        /// <returns>True if an error was logged.</returns>
        public static bool ErrorOnce(this TraceSource log, object token, string message, params object[] args)
        {
            lock (logOnceTokens)
            {
                var logtoken = new OnceLogToken { Token = token, Log = log };
                if (!logOnceTokens.Contains(logtoken))
                {
                    log.Error(message, args);
                    logOnceTokens.Add(logtoken);
                    return true;
                }

                return false;
            }
        }

        public static string ConvertToUnsecureString(this System.Security.SecureString securePassword)
        {
            if (securePassword == null)
                throw new ArgumentNullException("securePassword");

            IntPtr unmanagedString = IntPtr.Zero;
            try
            {
                unmanagedString = Marshal.SecureStringToGlobalAllocUnicode(securePassword);
                return Marshal.PtrToStringUni(unmanagedString);
            }
            finally
            {
                Marshal.ZeroFreeGlobalAllocUnicode(unmanagedString);
            }
        }

        public static System.Security.SecureString ToSecureString(this string str)
        {
            System.Security.SecureString result = new System.Security.SecureString();
            foreach (var c in str)
                result.AppendChar(c);
            return result;
        }

        public static bool IsNumeric(object obj)
        {
            switch (obj)
            {
                case float _: return true;
                case double _: return true;
                case decimal _: return true;
                case byte _: return true;
                case char _: return true;
                case sbyte _: return true;
                case short _: return true;
                case ushort _: return true;
                case int _: return true;
                case uint _: return true;
                case long _: return true;
                case ulong _: return true;
                default: return false;
            }

        }

        public static bool Compatible(Version searched, Version referenced)
        {
            if (searched == null) return true;

            if (searched.Major != referenced.Major) return false;
            if (searched.Minor >= referenced.Minor) return true;

            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="e"></param>
        /// <param name="flag"></param>
        /// <param name="enabled"></param>
        /// <returns></returns>
        public static T SetFlag<T>(this T e, T flag, bool enabled) where T : struct
        {
            if (e is Enum == false)
                throw new InvalidOperationException("T must be an enum");
            int _e = (int)Convert.ChangeType(e, typeof(int));
            int _flag = (int)Convert.ChangeType(flag, typeof(int));
            int r;
            if (enabled)
                r = (_e | _flag);
            else
                r = (_e & ~_flag);

            return (T)Enum.ToObject(typeof(T), r);
        }

        public static string EnumToReadableString(Enum value)
        {
            if (value == null) return null;
            var enumType = value.GetType();
            var mem = enumType.GetMember(value.ToString()).FirstOrDefault();
            if (mem != null) 
            { 
                return TranslationManager.TranslateEnum(value).Name;
            }
            if (false == enumType.HasAttribute<FlagsAttribute>())
                return value.ToString();
            var zeroValue = Enum.ToObject(enumType, 0);
            if (value.Equals(zeroValue))
                return ""; // this does not happen if zeroValue is declared.

            var flags = Enum.GetValues(enumType).OfType<Enum>();
            var activeFlags = flags.Where(value.HasFlag).Except(f => f.Equals(zeroValue));
            var result = string.Join(" | ", activeFlags.Select(EnumToReadableString));
            if (string.IsNullOrEmpty(result) == false) return result;

            // last resort.
            var val = (long)Convert.ChangeType(value, TypeCode.Int64);
            return val.ToString();
        }

        public static string EnumToDescription(Enum value)
        {
            if (value == null) return null;
            var enumType = value.GetType();
            var mem = enumType.GetMember(value.ToString()).FirstOrDefault();
            // if member is null, fall back to the readable enum string (or description is null)
            return mem?.GetDisplayAttribute().Description ?? EnumToReadableString(value);
        }

        public static string SerializeToString(this TestPlan plan, bool throwOnErrors = false)
        {
            using (var mem = new MemoryStream())
            {
                var serializer = new TapSerializer();
                plan.Save(mem, serializer);
                if (throwOnErrors && serializer.Errors.Any())
                    throw new Exception(string.Join("\n", serializer.Errors));
                return Encoding.UTF8.GetString(mem.ToArray());
            }
        }


        public static object DeserializeFromString(string str)
        {
            return new TapSerializer().DeserializeFromString(str);
        }

        public static T DeserializeFromString<T>(string str) => (T)DeserializeFromString(str);

        class ActionDisposable : IDisposable
        {
            Action action;
            public ActionDisposable(Action action) => this.action = action;

            public void Dispose()
            {
                action();
                action = null;
            }
        }

        public static IDisposable WithDisposable(Action action)
        {
            return new ActionDisposable(action);
        }

        /// <summary> Gets or creates a value based on the key. This is useful for caches. </summary>
        public static V GetOrCreateValue<K, V>(this Dictionary<K, V> dictionary, K key, Func<K, V> createValue)
        {
            if (dictionary.TryGetValue(key, out V value))
                return value;
            return dictionary[key] = createValue(key);
        }

        public static string BytesToReadable(long bytes)
        {
            if (bytes < 1000) return $"{bytes} B";
            if (bytes < 1000000) return $"{bytes / 1000.0:0.00} kB";
            if (bytes < 1000000000) return $"{bytes / 1000000.0:0.00} MB";
            return $"{bytes / 1000000000.0:0.00} GB";
        }

        /// <summary> Backoff strategy for Retry.  </summary>
        static void Backoff(int retry, int sleepBaseMs = 100)
        {
            const double backoffFactor = 2.0;
            const double jitterFactor = 0.2;
            double baseSleep = Math.Pow(backoffFactor, retry) * sleepBaseMs;
            
            // add a bit of jitter to avoid "thundering herd" problems.
            Random random = new Random();
            double jitterAmount = 1.0 + jitterFactor * (random.NextDouble() - 0.5);
            int totalSleep = (int)(baseSleep * jitterAmount);
            
            if (totalSleep > 0)
                TapThread.Sleep(totalSleep);
        }

        /// <summary> Retries calling a function a number of times if calling it fails. </summary>
        /// <param name="function">The function to call.</param>
        /// <param name="retryOn">an exception type to retry on. By default this is typeof(Exception)</param>
        /// <param name="maxRetries">default 5 times</param>
        /// <param name="moreExceptions"> more exceptions to retry on</param>
        /// <param name="sleepBaseMs"> The time to sleep at first iteration. Subsequent sleeps with be longer</param>
        public static void Retry(Action function, Type retryOn = null, int maxRetries = 5, Type[] moreExceptions = null,
            int sleepBaseMs = 100)
        {
            Retry<int>(() =>
            {
                function();
                return 0;
            }, retryOn, maxRetries, moreExceptions, sleepBaseMs);
        }

        /// <summary> Retries calling a function a number of times if calling it fails. </summary>
        /// <param name="function">The function to call.</param>
        /// <param name="retryOn">an exception type to retry on. By default this is typeof(Exception)</param>
        /// <param name="maxRetries">default 5 times</param>
        /// <param name="moreExceptions"> more exceptions to retry on</param>
        /// <param name="sleepBaseMs"> The time to sleep at first iteration. Subsequent sleeps with be longer</param>
        /// <typeparam name="T">the return type.</typeparam>
        /// <returns>The return value </returns>
        public static T Retry<T>(Func<T> function, Type retryOn = null, int maxRetries = 5, Type[] moreExceptions = null,
            int sleepBaseMs = 100)
        {
            if (retryOn == null)
                retryOn = typeof(Exception);
            var allExceptions = new[] { retryOn }.Concat(moreExceptions ?? Array.Empty<Type>()).ToArray();

            for (int i = 0; i < maxRetries - 1; i++)
            {

                try
                {
                    return function();
                }
                catch (Exception ex)
                {

                    while (ex is AggregateException a && a.InnerExceptions.Count == 1)
                    {
                        ex = a.InnerExceptions[0];
                    }

                    var exType = ex.GetType();
                    if (allExceptions.Any(x => x.IsAssignableFrom(exType)))
                    {
                        // if one of the expected exceptions.
                        Backoff(i, sleepBaseMs);
                        continue;
                    }

                    ExceptionDispatchInfo.Capture(ex).Throw();
                }
            }
            
            // on the last attempt just call the function directly
            return function();
        }
    }

    static internal class Sequence
    {
        /// <summary> Turns item into a one element array, unless it is null.</summary>
        public static T[] AsSingle<T>(this T item) => item == null ? Array.Empty<T>() : new[] {item};
        
        /// <summary>
        /// Like distinct but keeps the last item. Returns List because we need to iterate until last element anyway.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="items"></param>
        /// <returns></returns>
        public static List<T> DistinctLast<T>(this IEnumerable<T> items)
        {
            Dictionary<T, int> d = new Dictionary<T, int>();
            int i = 0;
            foreach (var item in items)
            {
                d[item] = i;
                i++;
            }
            return d.OrderBy(kv => kv.Value).Select(kv => kv.Key).ToList();
        }
        
        internal static int ProcessPattern<T1>(IEnumerator objs, Action<T1> f1)
        {
            while (objs.MoveNext())
            {
                switch (objs.Current)
                {
                    case T1 t:
                        f1(t);
                        return 1;
                }
            }
            return 0;
        }
        
        internal static int ProcessPattern<T1, T2>(IEnumerator objs, Action<T1> f1, Action<T2> f2 )
        {
            while (objs.MoveNext())
            {
                switch (objs.Current)
                {
                    case T1 t:
                        f1(t); 
                        return 1 + ProcessPattern(objs, f2);
                    case T2 t:
                        f2(t);
                        return 1 + ProcessPattern(objs, f1);
                }
            }
            return 0;
        }
        
        internal static int ProcessPattern<T1, T2, T3>(IEnumerator objs, Action<T1> f1, Action<T2> f2, Action<T3> f3 )
        {
            while (objs.MoveNext())
            {
                switch (objs.Current)
                {
                    case T1 t:
                        f1(t); 
                        return 1 + ProcessPattern(objs, f2, f3);
                    case T2 t:
                        f2(t);
                        return 1 + ProcessPattern(objs, f1, f3);
                    case T3 t:
                        f3(t);
                        return 1 + ProcessPattern(objs, f1, f2);
                }
            }
            return 0;
        }

        /// <summary> Adds elements that arent null to the list. </summary>
        internal static void AddExceptNull<T>(this ICollection<T> list, T x)
        {
            if (x != null)
                list.Add(x);
        }
        
        internal static int ProcessPattern<T1, T2, T3, T4>(IEnumerator objs, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4 )
        {
            while (objs.MoveNext())
            {
                switch (objs.Current)
                {
                    case T1 t:
                        f1(t); 
                        return 1 + ProcessPattern(objs, f2, f3, f4);
                    case T2 t:
                        f2(t);
                        return 1 + ProcessPattern(objs, f1, f3, f4);
                    case T3 t:
                        f3(t);
                        return 1 + ProcessPattern(objs, f1, f2, f4);
                    case T4 t:
                        f4(t);
                        return 1 + ProcessPattern(objs, f1, f2, f3);
                }
            }
            return 0;
        }
        
        public static int ProcessPattern<T1, T2, T3, T4, T5>(IEnumerator objs, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4 , Action<T5> f5 )
        {
            while (objs.MoveNext())
            {
                switch (objs.Current)
                {
                    case T1 t:
                        f1(t); 
                        return 1 + ProcessPattern(objs, f2, f3, f4, f5);
                    case T2 t:
                        f2(t);
                        return 1 + ProcessPattern(objs, f1, f3, f4, f5);
                    case T3 t:
                        f3(t);
                        return 1 + ProcessPattern(objs, f1, f2, f4, f5);
                    case T4 t:
                        f4(t);
                        return 1 + ProcessPattern(objs, f1, f2, f3, f5);
                    case T5 t:
                        f5(t);
                        return 1 + ProcessPattern(objs, f1, f2, f3, f4);
                }
            }
            return 0;
        }
        
        public static int ProcessPattern<T1, T2, T3, T4, T5, T6>(IEnumerator objs, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4 , Action<T5> f5, Action<T6> f6 )
        {
            while (objs.MoveNext())
            {
                switch (objs.Current)
                {
                    case T1 t:
                        f1(t); 
                        return 1 + ProcessPattern(objs, f2, f3, f4, f5, f6);
                    case T2 t:
                        f2(t);
                        return 1 + ProcessPattern(objs, f1, f3, f4, f5, f6);
                    case T3 t:
                        f3(t);
                        return 1 + ProcessPattern(objs, f1, f2, f4, f5,f6);
                    case T4 t:
                        f4(t);
                        return 1 + ProcessPattern(objs, f1, f2, f3, f5,f6);
                    case T5 t:
                        f5(t);
                        return 1 + ProcessPattern(objs, f1, f2, f3, f4,f6);
                    case T6 t:
                        f6(t);
                        return 1 + ProcessPattern(objs, f1, f2, f3, f4, f5);
                }
            }
            return 0;
        }
        
        public static int ProcessPattern<T1, T2>(IEnumerable<object> objs, Action<T1> f1, Action<T2> f2)
        {
            using (var e = objs.GetEnumerator())
                return ProcessPattern(e, f1, f2);
        }
        
        public static int ProcessPattern<T1, T2, T3>(IEnumerable<object> objs, Action<T1> f1, Action<T2> f2, Action<T3> f3)
        {
            using (var e = objs.GetEnumerator())
                return ProcessPattern(e, f1, f2, f3);
        }
        public static int ProcessPattern<T1, T2, T3, T4>(IEnumerable<object> objs, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4)
        {
            using (var e = objs.GetEnumerator())
                return ProcessPattern(e, f1, f2, f3, f4);
        }
        public static int ProcessPattern<T1, T2, T3, T4, T5>(IEnumerable<object> objs, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4, Action<T5> f5)
        {
            using (var e = objs.GetEnumerator())
                return ProcessPattern(e, f1, f2, f3, f4, f5);
        }
        public static int ProcessPattern<T1, T2, T3, T4, T5, T6>(IEnumerable<object> objs, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4, Action<T5> f5, Action<T6> f6)
        {
            using (var e = objs.GetEnumerator())
                return ProcessPattern(e, f1, f2, f3, f4, f5, f6);
        }

        /// <summary>
        /// Count the number of elements in an enumerable.
        /// </summary>
        public static int Count(this IEnumerable enumerable)
        {
            if (enumerable is ICollection col)
                return col.Count;
            int c = 0;
            foreach (var _ in enumerable)
                c++;
            return c;
        }

        /// <summary>
        /// iterates lists and generates pairs of each list. Once the end is reached for one of the lists, execution stops. 
        /// </summary>
        public static IEnumerable<(T1, T2)> Pairwise<T1, T2>(this IEnumerable<T1> a, IEnumerable<T2> b)
        {
            using(var ia = a.GetEnumerator())
            using (var ib = b.GetEnumerator())
            {
                while (ia.MoveNext() && ib.MoveNext())
                {
                    yield return (ia.Current, ib.Current);
                }
            }
        }
        
        /// <summary>
        ///  process the enumerable source N objects at a time.
        /// </summary>
        public static IEnumerable<T> Batch<T>(this IEnumerable<T> src, int N)
        {
                var buffer = new T[N];
                int cnt = 0;
                foreach (var elem in src)
                {
                    buffer[cnt] = elem;
                    cnt += 1;
                    if (cnt == N)
                    {
                        foreach (var elem2 in buffer)
                            yield return elem2;
                        cnt = 0;
                    }
                }
                foreach (var elem2 in buffer.Take(cnt))
                    yield return elem2;
        }

        public static void Append<T>(ref T[]  array, params T[] appendage)
        {
            int preLen = array.Length;
            Array.Resize(ref array, array.Length + appendage.Length);
            Array.Copy(appendage, 0, array, preLen, appendage.Length);
        }
       
        public static IEnumerable<T2> TrySelect<T, T2>(this IEnumerable<T> src, Func<T, T2> f,
            Action<Exception, T> handler) => src.TrySelect<T, T2, Exception>(f, handler);
        public static IEnumerable<T2> TrySelect<T, T2>(this IEnumerable<T> src, Func<T,T2> f,
            Action<Exception> handler) => src.TrySelect<T, T2, Exception>(f, (e,v) => handler(e));
        
        public static IEnumerable<T2> TrySelect<T, T2, T3>(this IEnumerable<T> src, Func<T, T2> f, Action<T3, T> handler) where T3: Exception
        {
            foreach (var x in src)
            {
                T2 y;
                try
                {
                    y = f(x);
                }
                catch(T3 e)
                {
                    handler(e, x);
                    continue;
                }
                yield return y;
            }
        }
    }
    
    internal static class Time
    {
        /// <summary>
        /// A TimeSpan from seconds that does not round to nearest millisecond. (TimeSpan.FromSeconds does that).
        /// </summary>
        /// <param name="seconds"></param>
        /// <returns></returns>
        public static TimeSpan FromSeconds(double seconds)
        {
            try
            {
                checked
                {
                    // if the multiplication here creates a number greater than
                    // long.Max (or overflows negatively), we just return
                    // TimeSpan.MaxValue/MinValue.
                    long ticks = (long)(seconds * 1e7);
                    return TimeSpan.FromTicks(ticks);
                }
            }
            catch (OverflowException)
            {
                if (double.IsNaN(seconds))
                    throw new ArithmeticException("Nan is not a supported time value.");
                
                if (seconds < 0)
                    return TimeSpan.MinValue;
                
                return TimeSpan.MaxValue;
            }
        }
    }
    
    /// <summary> Invoke an action after a timeout, unless canceled. </summary>
    class TimeoutOperation : IDisposable
    {
        /// <summary> Estimate of how long it takes for the user to loose patience.</summary>
        static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(2);
        
        TimeoutOperation(TimeSpan timeout, Action action)
        {
            this.timeout = timeout;
            this.action = action;
            tokenSource = new CancellationTokenSource(timeout);
        }
        readonly Action action;
        readonly TimeSpan timeout;
        readonly CancellationTokenSource tokenSource;
        
        bool isCompleted;
        void wait()
        {
            try
            {
                var token = tokenSource.Token;
                if (!token.IsCancellationRequested && WaitHandle.WaitTimeout == WaitHandle.WaitAny(new [] { token.WaitHandle, TapThread.Current.AbortToken.WaitHandle }, timeout))
                    action();
            }
            finally
            {
                lock (tokenSource)
                {
                    tokenSource.Dispose();
                    isCompleted = true;
                }
            }
        }

        /// <summary> Creates a new TimeoutOperation with a specific timeout. </summary>
        /// <param name="timeout"></param>
        /// <param name="actionOnTimeout"></param>
        /// <returns></returns>
        public static TimeoutOperation Create(TimeSpan timeout, Action actionOnTimeout)
        {
            TimeoutOperation operation = new TimeoutOperation(timeout, actionOnTimeout);
            TapThread.Start(operation.wait, "Timeout");
            return operation;
        }

        /// <summary> Creates a timeout operation with the default timeout. </summary>
        /// <param name="actionOnTimeout"></param>
        /// <returns></returns>
        public static TimeoutOperation Create(Action actionOnTimeout)
        {
            return Create(DefaultTimeout, actionOnTimeout);
        }

        /// <summary>
        /// Cancel invoking the action after the timeout.
        /// </summary>
        public void Cancel()
        {
            try
            {
                lock (tokenSource)
                {
                    if (!isCompleted)
                        tokenSource.Cancel();
                }
            }
            catch (ObjectDisposedException)
            {

            }
        }

        public void Dispose()
        {
            Cancel();
        }
    }
}