using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;

namespace OpenTap.Addin.Reader
{
    public abstract class IObjectReader
    {
        internal const string TypeAttrName = "type";

        public abstract object ReadObject(Type type, XElement element, Action<object> postAction);
    }

    public class DefaultObjectReader
    {
        static readonly Dictionary<Type, IObjectReader> SpecialReader = new Dictionary<Type, IObjectReader>();

        static DefaultObjectReader()
        {
            SpecialReader.Add(typeof(TestStepList), new TestStepListReader());
        }

        static bool tryConvertNumber(Type type, string valueString, out object value)
        {
            switch (Type.GetTypeCode(type))
            {
                case TypeCode.Byte:
                    {
                        byte oval;
                        bool ok = byte.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }
                case TypeCode.SByte:
                    {
                        SByte oval;
                        bool ok = SByte.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }
                case TypeCode.UInt16:
                    {
                        UInt16 oval;
                        bool ok = UInt16.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }
                case TypeCode.UInt32:
                    {
                        UInt32 oval;
                        bool ok = UInt32.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }
                case TypeCode.UInt64:
                    {
                        UInt64 oval;
                        bool ok = UInt64.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }

                case TypeCode.Int16:
                    {
                        Int16 oval;
                        bool ok = Int16.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }
                case TypeCode.Int32:
                    {
                        Int32 oval;
                        bool ok = Int32.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }
                case TypeCode.Int64:
                    {
                        Int64 oval;
                        bool ok = Int64.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }
                case TypeCode.Decimal:
                    {
                        value = BigFloat.Convert(valueString, CultureInfo.InvariantCulture).ConvertTo(typeof(decimal));
                        return true;
                    }
                case TypeCode.Double:
                    {
                        Double oval;
                        bool ok = Double.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }
                case TypeCode.Single:
                    {
                        Single oval;
                        bool ok = Single.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out oval);
                        value = oval;
                        return ok;
                    }
                default:
                    value = null;
                    return false;
            }
        }

        static bool readContentInternal(Type propType, Func<string> getvalueString, XElement elem, out object outvalue)
        {

            object value = null;
            bool ok;

            if (propType.IsEnum || propType.IsPrimitive || propType == typeof(string) || propType.IsValueType || propType == typeof(Type))
            {
                ok = true;
                string valueString = getvalueString()?.Trim();

                if (propType.IsEnum)
                {
                    if (!string.IsNullOrEmpty(valueString))
                    {
                        // legacy support: A flagged enum did not have ','s, but just spaces between.
                        if (!valueString.Contains(','))
                        {
                            var splitted = valueString.Split(' ');
                            value = Enum.Parse(propType, string.Join(",", splitted));
                        }
                        else
                            value = Enum.Parse(propType, valueString);
                    }
                }

                else if (propType == typeof(String) || propType == typeof(char))
                {
                    if (elem.HasElements)
                    {
                        // string contains Base64 if it has invalid XML chars.
                        // elem.Element("Base64") fails if the attribute "xmlns" is set on the document.
                        // In this case, "Base64" must be prepended with the value of xmlns in brackets.
                        // If the namespace is not set, ns.GetName("Base64") will just evaluate to "Base64"
                        var ns = elem.GetDefaultNamespace();
                        var encode = elem.Element(ns.GetName("Base64"));
                        if (encode != null)
                        {
                            try
                            {
                                value = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encode.Value));
                            }
                            catch
                            {
                                value = encode.Value;
                            }
                        }
                    }
                    if (value == null)
                        value = valueString;
                    if (propType == typeof(char))
                        value = ((string)value)[0];
                }
                else if (propType == typeof(TimeSpan) || propType == typeof(TimeSpan?))
                {
                    value = TimeSpan.Parse(valueString, CultureInfo.InvariantCulture);
                }
                else if (propType == typeof(Guid) || propType == typeof(Guid?))
                {
                    value = Guid.Parse(valueString);
                }
                else if (propType == typeof(Type))
                {
                    value = PluginManager.LocateType(valueString.Split(',').First());
                }
                else if (tryConvertNumber(propType, valueString, out value))
                {
                    // Conversions done in tryConvertNumber
                }
                else if (typeof(IConvertible).IsAssignableFrom(propType))
                {
                    value = Convert.ChangeType(valueString, propType, CultureInfo.InvariantCulture);
                }
                else if (propType.IsGenericType && propType.GetGenericTypeDefinition() == typeof(Nullable<>))
                {
                    // For nullable<T> we recurse focusing on the underlying non-nullable type.
                    if (valueString == null)
                    {
                        outvalue = null;
                        return true; // null is a valid value for nullable types.
                    }

                    return readContentInternal(Nullable.GetUnderlyingType(propType), getvalueString, elem, out outvalue);
                }
                else
                {
                    ok = false;
                }
            }
            else
            {
                ok = false;
            }

            outvalue = value;
            return ok;
        }

        public static object ReadObject(Type type, XElement element, Action<object> postAction)
        {
            //var timer = Stopwatch.StartNew();
            if (type == null || element == null)
                return null;
            object obj = null;
            if (SpecialReader.ContainsKey(type))
            {
                obj = SpecialReader[type].ReadObject(type, element, postAction);
                //TestPlanReader.Log.Debug(timer, $"Create {obj}");
                return obj;
            }
            else
            {
                var typeAttr = element.Attribute(IObjectReader.TypeAttrName);
                type = typeAttr == null ? type : Type.GetType(typeAttr.Value);
                if (type == null)
                {
                    var td = TypeData.GetTypeData(typeAttr.Value);
                    obj = td.CreateInstance();
                    type = obj.GetType();
                }

                if (!readContentInternal(type, () => element.Value, element, out obj))
                {
                    try
                    {
                        obj = obj ?? Activator.CreateInstance(type);
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }

                    if (typeof(IList).IsAssignableFrom(type) && type.IsGenericType)
                    {
                        var list = (IList)obj;
                        var eles = element.Elements().ToArray();
                        var values = new object[eles.Length];

                        Parallel.For(0, eles.Length, i => values[i] = ReadObject(type.GetGenericArguments().First(), eles[i], postAction));

                        //var values = element.Elements().AsParallel().AsOrdered().Select(childElemennt =>
                        //{
                        //    return ;
                        //}).ToArray();

                        foreach (var val in values)
                        {
                            list.Add(val);
                        }

                        //foreach (var childElemennt in element.Elements())
                        //{
                        //    var value = ReadObject(type.GetGenericArguments().First(), childElemennt, postAction);
                        //    list.Add(value);
                        //}
                    }
                    else
                    {
                        var props = PropertyInfoCache.GetProps(type);

                        foreach (var childElemennt in element.Elements())
                        {
                            string childName = XmlConvert.DecodeName(childElemennt.Name.LocalName);
                            if (!props.ContainsKey(childName))
                            {
                                continue;
                            }
                            var prop = props[childName];
                            var value = ReadObject(prop.PropertyType, childElemennt, postAction);
                            prop.SetValue(obj, value);
                        }

                        //List<Task> tasks = new List<Task>();
                        //foreach (var childElemennt in element.Elements())
                        //{
                        //    string childName = XmlConvert.DecodeName(childElemennt.Name.LocalName);
                        //    if (!props.ContainsKey(childName))
                        //    {
                        //        continue;
                        //    }
                        //    tasks.Add(Task.Run(() =>
                        //    {
                        //        

                        //    }));
                        //}
                        //Task.WaitAll(tasks.ToArray());

                        //var eles = element.Elements().ToArray();
                        //Parallel.For(0, eles.Length, i =>
                        //{
                        //    string childName = XmlConvert.DecodeName(eles[i].Name.LocalName);
                        //    if (!props.ContainsKey(childName))
                        //    {
                        //        return;
                        //    }
                        //    var prop = props[childName];
                        //    var value = ReadObject(prop.PropertyType, eles[i], postAction);
                        //    prop.SetValue(obj, value);
                        //});
                    }
                    //TestPlanReader.Log.Debug(timer, $"Create {obj}");
                }
                if (postAction != null) postAction(obj);
                return obj;
            }
        }
    }
}