using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;

namespace Developpez.Dotnet
{
    internal static class CompatibilityHelper
    {
        public static class Enum
        {
            public static IEnumerable GetValues(System.Type type)
            {
#if SILVERLIGHT
                var fields = type.GetFields(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
                return fields.Where(f => f.IsLiteral).Select(f => f.GetValue(null)).ToArray();
#else
                return System.Enum.GetValues(type);
#endif
            }

            
        }

        public class RegexOptions
        {
#if SILVERLIGHT || NETFX_CORE
            public const System.Text.RegularExpressions.RegexOptions Compiled = System.Text.RegularExpressions.RegexOptions.None;
#else
            public const System.Text.RegularExpressions.RegexOptions Compiled = System.Text.RegularExpressions.RegexOptions.Compiled;
#endif
        }

        public class Math
        {
            public static int DivRem(int a, int b, out int result)
            {
#if SILVERLIGHT || NETFX_CORE
                int c = a / b;
                result = a - (b * c);
                return c;
#else
            return System.Math.DivRem(a, b, out result);
#endif
            }

            public static long DivRem(long a, long b, out long result)
            {
#if SILVERLIGHT || NETFX_CORE
                long c = a / b;
                result = a - (b * c);
                return c;
#else
            return System.Math.DivRem(a, b, out result);
#endif
            }

            public static double Truncate(double value)
            {
#if SILVERLIGHT
                return value < 0 ? System.Math.Ceiling(value) : System.Math.Floor(value);
#else
                return System.Math.Truncate(value);
#endif
            }

            public static decimal Truncate(decimal value)
            {
#if SILVERLIGHT
                return decimal.Truncate(value);
#else
                return System.Math.Truncate(value);
#endif
            }

        }

        public class StringComparer
        {
#if NETFX_CORE
            private static readonly InvariantCultureStringComparer _invariantCulture = new InvariantCultureStringComparer(false);
            public static InvariantCultureStringComparer InvariantCulture
            {
                get { return _invariantCulture; }
            }

            private static readonly InvariantCultureStringComparer _invariantCultureIgnoreCase = new InvariantCultureStringComparer(true);
            public static InvariantCultureStringComparer InvariantCultureIgnoreCase
            {
                get { return _invariantCultureIgnoreCase; }
            }

            public class InvariantCultureStringComparer : IEqualityComparer<string>, IComparer<string>
            {
                private readonly bool _ignoreCase;
                private readonly CompareInfo _compareInfo;

                public InvariantCultureStringComparer(bool ignoreCase)
                {
                    _compareInfo = CultureInfo.InvariantCulture.CompareInfo;
                    _ignoreCase = ignoreCase;
                }

                public bool Equals(string x, string y)
                {
                    var options = CompareOptions.None;
                    if (_ignoreCase)
                        options = CompareOptions.IgnoreCase;
                    return _compareInfo.Compare(x, y, options) == 0;
                }

                public int GetHashCode(string obj)
                {
                    if (obj == null)
                        return 0;
                    if (_ignoreCase)
                        obj = obj.ToLowerInvariant();
                    return obj.GetHashCode();
                }

                public int Compare(string x, string y)
                {
                    var options = CompareOptions.None;
                    if (_ignoreCase)
                        options = CompareOptions.IgnoreCase;
                    return _compareInfo.Compare(x, y, options);
                }
            }
#else
            public static System.StringComparer InvariantCulture { get { return System.StringComparer.InvariantCulture; } }
            public static System.StringComparer InvariantCultureIgnoreCase { get { return System.StringComparer.InvariantCultureIgnoreCase; } }
#endif
        }
    }

}