using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Xml;
using Umbraco.Core.Plugins;

namespace Umbraco.Core
{
	/// <summary>
	/// Provides object extension methods.
	/// </summary>
	public static class ObjectExtensions
	{
		//private static readonly ConcurrentDictionary<Type, Func<object>> ObjectFactoryCache = new ConcurrentDictionary<Type, Func<object>>();

		/// <summary>
		/// 
		/// </summary>
		/// <param name="input"></param>
		/// <typeparam name="T"></typeparam>
		/// <returns></returns>
		public static IEnumerable<T> AsEnumerableOfOne<T>(this T input)
		{
			return Enumerable.Repeat(input, 1);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="input"></param>
		public static void DisposeIfDisposable(this object input)
		{
			var disposable = input as IDisposable;
			if (disposable != null) disposable.Dispose();
		}

		/// <summary>
		/// Provides a shortcut way of safely casting an input when you cannot guarantee the <typeparamref name="T"/> is
		/// an instance type (i.e., when the C# AS keyword is not applicable).
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="input">The input.</param>
		/// <returns></returns>
		internal static T SafeCast<T>(this object input)
		{
			if (ReferenceEquals(null, input) || ReferenceEquals(default(T), input)) return default(T);
			if (input is T) return (T)input;
			return default(T);
		}

		/// <summary>
		/// Tries to convert the input object to the output type using TypeConverters
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="input"></param>
		/// <returns></returns>
		public static Attempt<T> TryConvertTo<T>(this object input)
		{
			var result = TryConvertTo(input, typeof(T));
            if (result.Success == false)
            {
                //just try a straight up conversion
                try
                {
                    var converted = (T) input;
                    return Attempt<T>.Succeed(converted);
                }
                catch (Exception e)
                {
                    return Attempt<T>.Fail(e);
                }
            }
			return result.Success == false ? Attempt<T>.Fail() : Attempt<T>.Succeed((T)result.Result);
		}

		/// <summary>
		/// Tries to convert the input object to the output type using TypeConverters. If the destination
		/// type is a superclass of the input type, if will use <see cref="Convert.ChangeType(object,System.Type)"/>.
		/// </summary>
		/// <param name="input">The input.</param>
		/// <param name="destinationType">Type of the destination.</param>
		/// <returns></returns>
		public static Attempt<object> TryConvertTo(this object input, Type destinationType)
		{
            // if null...
		    if (input == null)
		    {
		        // nullable is ok
                if (destinationType.IsGenericType && destinationType.GetGenericTypeDefinition() == typeof(Nullable<>))
                    return Attempt<object>.Succeed(null);

                // value type is nok, else can be null, so is ok
		        return Attempt<object>.If(destinationType.IsValueType == false, null);
            }

            // easy
			if (destinationType == typeof(object)) return Attempt.Succeed(input);
			if (input.GetType() == destinationType) return Attempt.Succeed(input);

            // check for string so that overloaders of ToString() can take advantage of the conversion.
            if (destinationType == typeof(string)) return Attempt<object>.Succeed(input.ToString());

			// if we've got a nullable of something, we try to convert directly to that thing.
			if (destinationType.IsGenericType && destinationType.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
			    var underlyingType = Nullable.GetUnderlyingType(destinationType);

                //special case for empty strings for bools/dates which should return null if an empty string
			    var asString = input as string;
			    if (asString != null && string.IsNullOrEmpty(asString) && (underlyingType == typeof(DateTime) || underlyingType == typeof(bool)))
                {
                    return Attempt<object>.Succeed(null);
                }

				// recursively call into myself with the inner (not-nullable) type and handle the outcome
                var nonNullable = input.TryConvertTo(underlyingType);

				// and if sucessful, fall on through to rewrap in a nullable; if failed, pass on the exception
				if (nonNullable.Success)
					input = nonNullable.Result; // now fall on through...
				else
					return Attempt<object>.Fail(nonNullable.Exception);
			}

			// we've already dealed with nullables, so any other generic types need to fall through
			if (destinationType.IsGenericType == false)
			{
				if (input is string)
				{
                    // try convert from string, returns an Attempt if the string could be
                    // processed (either succeeded or failed), else null if we need to try
                    // other methods
					var result = TryConvertToFromString(input as string, destinationType);
					if (result.HasValue) return result.Value;
				}

                //TODO: Do a check for destination type being IEnumerable<T> and source type implementing IEnumerable<T> with
                // the same 'T', then we'd have to find the extension method for the type AsEnumerable() and execute it.

				if (TypeHelper.IsTypeAssignableFrom(destinationType, input.GetType())
					&& TypeHelper.IsTypeAssignableFrom<IConvertible>(input))
				{
                    try
                    {
                        var casted = Convert.ChangeType(input, destinationType);
                        return Attempt.Succeed(casted);
                    }
                    catch (Exception e)
                    {
                        return Attempt<object>.Fail(e);
                    }
				}
			}

			var inputConverter = TypeDescriptor.GetConverter(input);
			if (inputConverter.CanConvertTo(destinationType))
			{
				try
				{
					var converted = inputConverter.ConvertTo(input, destinationType);
					return Attempt.Succeed(converted);
				}
				catch (Exception e)
				{
					return Attempt<object>.Fail(e);
				}
			}

			if (destinationType == typeof(bool))
			{
				var boolConverter = new CustomBooleanTypeConverter();
				if (boolConverter.CanConvertFrom(input.GetType()))
				{
					try
					{
						var converted = boolConverter.ConvertFrom(input);
						return Attempt.Succeed(converted);
					}
					catch (Exception e)
					{
						return Attempt<object>.Fail(e);
					}
				}
			}

			var outputConverter = TypeDescriptor.GetConverter(destinationType);
			if (outputConverter.CanConvertFrom(input.GetType()))
			{
				try
				{
					var converted = outputConverter.ConvertFrom(input);
					return Attempt.Succeed(converted);
				}
				catch (Exception e)
				{
					return Attempt<object>.Fail(e);
				}
			}

			if (TypeHelper.IsTypeAssignableFrom<IConvertible>(input))
			{
				try
				{
					var casted = Convert.ChangeType(input, destinationType);
					return Attempt.Succeed(casted);
				}
				catch (Exception e)
				{
					return Attempt<object>.Fail(e);
				}
			}

			return Attempt<object>.Fail();
		}

        // returns an attempt if the string has been processed (either succeeded or failed)
        // returns null if we need to try other methods
		private static Attempt<object>? TryConvertToFromString(this string input, Type destinationType)
		{
            // easy
			if (destinationType == typeof(string))
				return Attempt<object>.Succeed(input);

            // null, empty, whitespaces
			if (string.IsNullOrWhiteSpace(input))
			{
				if (destinationType == typeof(bool)) // null/empty = bool false
					return Attempt<object>.Succeed(false);
				if (destinationType == typeof(DateTime)) // null/empty = min DateTime value
                    return Attempt<object>.Succeed(DateTime.MinValue);

			    // cannot decide here,
                // any of the types below will fail parsing and will return a failed attempt
                // but anything else will not be processed and will return null
                // so even though the string is null/empty we have to proceed
			}

			// look for type conversions in the expected order of frequency of use...
			if (destinationType.IsPrimitive)
			{
			    if (destinationType == typeof(int)) // aka Int32
				{
					int value;
				    if (int.TryParse(input, out value)) return Attempt<object>.Succeed(value);

                    // because decimal 100.01m will happily convert to integer 100, it
                    // makes sense that string "100.01" *also* converts to integer 100.
                    decimal value2;
                    var input2 = NormalizeNumberDecimalSeparator(input);
                    return Attempt<object>.If(decimal.TryParse(input2, out value2), Convert.ToInt32(value2));
                }

                if (destinationType == typeof(long)) // aka Int64
			    {
			        long value;
			        if (long.TryParse(input, out value)) return Attempt<object>.Succeed(value);

                    // same as int
                    decimal value2;
                    var input2 = NormalizeNumberDecimalSeparator(input);
			        return Attempt<object>.If(decimal.TryParse(input2, out value2), Convert.ToInt64(value2));
			    }

                // fixme - should we do the decimal trick for short, byte, unsigned?

			    if (destinationType == typeof(bool)) // aka Boolean
			    {
			        bool value;
			        if (bool.TryParse(input, out value)) return Attempt<object>.Succeed(value);
                    // don't declare failure so the CustomBooleanTypeConverter can try
                    return null;
			    }

			    if (destinationType == typeof(short)) // aka Int16
			    {
			        short value;
			        return Attempt<object>.If(short.TryParse(input, out value), value);
			    }

			    if (destinationType == typeof(double)) // aka Double
			    {
			        double value;
			        var input2 = NormalizeNumberDecimalSeparator(input);
			        return Attempt<object>.If(double.TryParse(input2, out value), value);
			    }

			    if (destinationType == typeof(float)) // aka Single
			    {
			        float value;
			        var input2 = NormalizeNumberDecimalSeparator(input);
			        return Attempt<object>.If(float.TryParse(input2, out value), value);
			    }

			    if (destinationType == typeof(char)) // aka Char
			    {
			        char value;
			        return Attempt<object>.If(char.TryParse(input, out value), value);
			    }

			    if (destinationType == typeof(byte)) // aka Byte
			    {
			        byte value;
			        return Attempt<object>.If(byte.TryParse(input, out value), value);
			    }

			    if (destinationType == typeof(sbyte)) // aka SByte
                {
			        sbyte value;
			        return Attempt<object>.If(sbyte.TryParse(input, out value), value);
                }

			    if (destinationType == typeof(uint)) // aka UInt32
                {
			        uint value;
			        return Attempt<object>.If(uint.TryParse(input, out value), value);
                }

			    if (destinationType == typeof(ushort)) // aka UInt16
                {
			        ushort value;
			        return Attempt<object>.If(ushort.TryParse(input, out value), value);
                }

			    if (destinationType == typeof(ulong)) // aka UInt64
                {
			        ulong value;
                    return Attempt<object>.If(ulong.TryParse(input, out value), value);
			    }
			}
			else if (destinationType == typeof(Guid))
			{
				Guid value;
			    return Attempt<object>.If(Guid.TryParse(input, out value), value);
			}
			else if (destinationType == typeof(DateTime))
			{
				DateTime value;
			    if (DateTime.TryParse(input, out value))
			    {
			        switch (value.Kind)
			        {
			            case DateTimeKind.Unspecified:
			            case DateTimeKind.Utc:
                            return Attempt<object>.Succeed(value);
			            case DateTimeKind.Local:
			                return Attempt<object>.Succeed(value.ToUniversalTime());
			            default:
			                throw new ArgumentOutOfRangeException();
			        }
			    }
			    return Attempt<object>.Fail();
			}
			else if (destinationType == typeof(DateTimeOffset))
			{
				DateTimeOffset value;
			    return Attempt<object>.If(DateTimeOffset.TryParse(input, out value), value);
			}
			else if (destinationType == typeof(TimeSpan))
			{
				TimeSpan value;
			    return Attempt<object>.If(TimeSpan.TryParse(input, out value), value);
			}
			else if (destinationType == typeof(decimal)) // aka Decimal
			{
				decimal value;
                var input2 = NormalizeNumberDecimalSeparator(input);
                return Attempt<object>.If(decimal.TryParse(input2, out value), value);
			}
			else if (destinationType == typeof(Version))
			{
				Version value;
			    return Attempt<object>.If(Version.TryParse(input, out value), value);
			}
			// E_NOTIMPL IPAddress, BigInteger

			return null; // we can't decide...
		}

        private static readonly char[] NumberDecimalSeparatorsToNormalize = {'.', ','};

	    private static string NormalizeNumberDecimalSeparator(string s)
	    {
	        var normalized = System.Threading.Thread.CurrentThread.CurrentCulture.NumberFormat.NumberDecimalSeparator[0];
            return s.ReplaceMany(NumberDecimalSeparatorsToNormalize, normalized);
	    }

		internal static void CheckThrowObjectDisposed(this IDisposable disposable, bool isDisposed, string objectname)
		{
			//TODO: Localise this exception
			if (isDisposed)
				throw new ObjectDisposedException(objectname);
		}

		//public enum PropertyNamesCaseType
		//{
		//    CamelCase,
		//    CaseInsensitive
		//}

		///// <summary>
		///// Convert an object to a JSON string with camelCase formatting
		///// </summary>
		///// <param name="obj"></param>
		///// <returns></returns>
		//public static string ToJsonString(this object obj)
		//{
		//    return obj.ToJsonString(PropertyNamesCaseType.CamelCase);
		//}

		///// <summary>
		///// Convert an object to a JSON string with the specified formatting
		///// </summary>
		///// <param name="obj">The obj.</param>
		///// <param name="propertyNamesCaseType">Type of the property names case.</param>
		///// <returns></returns>
		//public static string ToJsonString(this object obj, PropertyNamesCaseType propertyNamesCaseType)
		//{
		//    var type = obj.GetType();
		//    var dateTimeStyle = "yyyy-MM-dd HH:mm:ss";

		//    if (type.IsPrimitive || typeof(string).IsAssignableFrom(type))
		//    {
		//        return obj.ToString();
		//    }

		//    if (typeof(DateTime).IsAssignableFrom(type) || typeof(DateTimeOffset).IsAssignableFrom(type))
		//    {
		//        return Convert.ToDateTime(obj).ToString(dateTimeStyle);
		//    }

		//    var serializer = new JsonSerializer();

		//    switch (propertyNamesCaseType)
		//    {
		//        case PropertyNamesCaseType.CamelCase:
		//            serializer.ContractResolver = new CamelCasePropertyNamesContractResolver();
		//            break;
		//    }

		//    var dateTimeConverter = new IsoDateTimeConverter
		//        {
		//            DateTimeStyles = System.Globalization.DateTimeStyles.None,
		//            DateTimeFormat = dateTimeStyle
		//        };

		//    if (typeof(IDictionary).IsAssignableFrom(type))
		//    {
		//        return JObject.FromObject(obj, serializer).ToString(Formatting.None, dateTimeConverter);
		//    }

		//    if (type.IsArray || (typeof(IEnumerable).IsAssignableFrom(type)))
		//    {
		//        return JArray.FromObject(obj, serializer).ToString(Formatting.None, dateTimeConverter);
		//    }

		//    return JObject.FromObject(obj, serializer).ToString(Formatting.None, dateTimeConverter);
		//}

		/// <summary>
		/// Converts an object into a dictionary
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <typeparam name="TProperty"></typeparam>
		/// <typeparam name="TVal"> </typeparam>
		/// <param name="o"></param>
		/// <param name="ignoreProperties"></param>
		/// <returns></returns>
        public static IDictionary<string, TVal> ToDictionary<T, TProperty, TVal>(this T o,
																				 params Expression<Func<T, TProperty>>[] ignoreProperties)
		{
			return o.ToDictionary<TVal>(ignoreProperties.Select(e => o.GetPropertyInfo(e)).Select(propInfo => propInfo.Name).ToArray());
		}

        /// <summary>
        /// Turns object into dictionary
        /// </summary>
        /// <param name="o"></param>
        /// <param name="ignoreProperties">Properties to ignore</param>
        /// <returns></returns>
        public static IDictionary<string, TVal> ToDictionary<TVal>(this object o, params string[] ignoreProperties)
		{
			if (o != null)
			{
				var props = TypeDescriptor.GetProperties(o);
				var d = new Dictionary<string, TVal>();
				foreach (var prop in props.Cast<PropertyDescriptor>().Where(x => ignoreProperties.Contains(x.Name) == false))
				{
					var val = prop.GetValue(o);
					if (val != null)
					{
						d.Add(prop.Name, (TVal)val);
					}
				}
				return d;
			}
			return new Dictionary<string, TVal>();
		}

		internal static string ToDebugString(this object obj, int levels = 0)
		{
			if (obj == null) return "{null}";
			try
			{
				if (obj is string)
				{
					return "\"{0}\"".InvariantFormat(obj);
				}
                if (obj is int || obj is Int16 || obj is Int64 || obj is float || obj is double || obj is bool || obj is int? || obj is Int16? || obj is Int64? || obj is float? || obj is double? || obj is bool?)
				{
					return "{0}".InvariantFormat(obj);
				}
				if (obj is Enum)
				{
					return "[{0}]".InvariantFormat(obj);
				}
				if (obj is IEnumerable)
				{
					var enumerable = (obj as IEnumerable);

					var items = (from object enumItem in enumerable let value = GetEnumPropertyDebugString(enumItem, levels) where value != null select value).Take(10).ToList();

					return items.Any()
							? "{{ {0} }}".InvariantFormat(String.Join(", ", items))
							: null;
				}

				var props = obj.GetType().GetProperties();
				if ((props.Length == 2) && props[0].Name == "Key" && props[1].Name == "Value" && levels > -2)
				{
					try
					{
						var key = props[0].GetValue(obj, null) as string;
						var value = props[1].GetValue(obj, null).ToDebugString(levels - 1);
						return "{0}={1}".InvariantFormat(key, value);
					}
					catch (Exception)
					{
						return "[KeyValuePropertyException]";
					}
				}
				if (levels > -1)
				{
					var items =
						(from propertyInfo in props
						let value = GetPropertyDebugString(propertyInfo, obj, levels)
						where value != null
						select "{0}={1}".InvariantFormat(propertyInfo.Name, value)).ToArray();

					return items.Any()
							? "[{0}]:{{ {1} }}".InvariantFormat(obj.GetType().Name, String.Join(", ", items))
							: null;
				}
			}
			catch (Exception ex)
			{
				return "[Exception:{0}]".InvariantFormat(ex.Message);
			}
			return null;
		}


		/// <summary>
		/// Attempts to serialize the value to an XmlString using ToXmlString
		/// </summary>
		/// <param name="value"></param>
		/// <param name="type"></param>
		/// <returns></returns>
		internal static Attempt<string> TryConvertToXmlString(this object value, Type type)
		{
			try
			{
				var output = value.ToXmlString(type);
				return Attempt.Succeed(output);
			}
			catch (NotSupportedException ex)
			{
				return Attempt<string>.Fail(ex);
			}
		}

		/// <summary>
		/// Returns an XmlSerialized safe string representation for the value
		/// </summary>
		/// <param name="value"></param>
		/// <param name="type">The Type can only be a primitive type or Guid and byte[] otherwise an exception is thrown</param>
		/// <returns></returns>
		internal static string ToXmlString(this object value, Type type)
		{
		    if (value == null) return string.Empty;
			if (type == typeof(string)) return (value.ToString().IsNullOrWhiteSpace() ? "" : value.ToString());
			if (type == typeof(bool)) return XmlConvert.ToString((bool)value);
			if (type == typeof(byte)) return XmlConvert.ToString((byte)value);
			if (type == typeof(char)) return XmlConvert.ToString((char)value);
            if (type == typeof(DateTime)) return XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.Unspecified);
			if (type == typeof(DateTimeOffset)) return XmlConvert.ToString((DateTimeOffset)value);
			if (type == typeof(decimal)) return XmlConvert.ToString((decimal)value);
			if (type == typeof(double)) return XmlConvert.ToString((double)value);
			if (type == typeof(float)) return XmlConvert.ToString((float)value);
			if (type == typeof(Guid)) return XmlConvert.ToString((Guid)value);
			if (type == typeof(int)) return XmlConvert.ToString((int)value);
			if (type == typeof(long)) return XmlConvert.ToString((long)value);
			if (type == typeof(sbyte)) return XmlConvert.ToString((sbyte)value);
			if (type == typeof(short)) return XmlConvert.ToString((short)value);
			if (type == typeof(TimeSpan)) return XmlConvert.ToString((TimeSpan)value);
			if (type == typeof(bool)) return XmlConvert.ToString((bool)value);
			if (type == typeof(uint)) return XmlConvert.ToString((uint)value);
			if (type == typeof(ulong)) return XmlConvert.ToString((ulong)value);
			if (type == typeof(ushort)) return XmlConvert.ToString((ushort)value);

			throw new NotSupportedException("Cannot convert type " + type.FullName + " to a string using ToXmlString as it is not supported by XmlConvert");
		}

        /// <summary>
        /// Returns an XmlSerialized safe string representation for the value and type
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <returns></returns>
	    internal static string ToXmlString<T>(this object value)
	    {
	        return value.ToXmlString(typeof (T));
	    }

	    private static string GetEnumPropertyDebugString(object enumItem, int levels)
		{
			try
			{
				return enumItem.ToDebugString(levels - 1);
			}
			catch (Exception)
			{
				return "[GetEnumPartException]";
			}
		}

		private static string GetPropertyDebugString(PropertyInfo propertyInfo, object obj, int levels)
		{
			try
			{
				return propertyInfo.GetValue(obj, null).ToDebugString(levels - 1);
			}
			catch (Exception)
			{
				return "[GetPropertyValueException]";
			}
		}

	    internal static Guid AsGuid(this object value)
	    {
	        return value is Guid ? (Guid) value : Guid.Empty;
	    }
	}
}