//            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.Generic;
using System.Linq;
using System.Xml.Linq;
using System.Globalization;
using System.Collections;

namespace OpenTap.Plugins
{
    /// <summary> Serializer implementation for Collections. </summary>
    internal class CollectionSerializer : TapSerializerPlugin, IConstructingSerializer
    {
        /// <summary> Order of this serializer.   </summary>
        public override double Order { get; } = 1;
        
        /// <summary> Current serializing element type. </summary>
        public Type CurrentElementType { get; private set; }

        /// <summary> Deserialization implementation. </summary>
        public override bool Deserialize( XElement element, ITypeData _t, Action<object> setResult)
        {
            object prevobj = this.Object;
            var prevElementType = CurrentElementType;
            try
            {
                var t = (_t as TypeData)?.Type;
                if (t == null || !t.DescendsTo(typeof(IEnumerable)) || t == typeof(string)) return false;

                IEnumerable finalValues = null;
                Type genericType = t.GetEnumerableElementType() ?? typeof(object);
                CurrentElementType = genericType;
                if (t.IsArray == false && t.HasInterface<IList>() && t.GetConstructor(Type.EmptyTypes) != null &&
                    genericType.IsValueType == false)
                {
                    finalValues = (IList) Activator.CreateInstance(t);
                }

                if (finalValues == null)
                    finalValues = new List<object>();

                var prevSetResult = setResult;
                setResult = x =>
                {
                    // ensure that IDeserializedCallback is going to get used.
                    prevSetResult(x);
                    var deserializedHandler = x as IDeserializedCallback;
                    if (deserializedHandler != null)
                    {
                        Serializer.DeferLoad(() =>
                        {
                            try
                            {
                                deserializedHandler.OnDeserialized();
                            }
                            catch (Exception e)
                            {
                                Log.Warning("Exception caught while handling OnDeserialized");
                                Log.Debug(e);
                            }
                        });
                    }
                }; 

                bool tryGetFactory(out Func<IList> ctor)
                {
                    var os = Serializer.SerializerStack
                        .OfType<ObjectSerializer>()
                        .FirstOrDefault();
                    if (os?.CurrentMember is IMemberData member
                        && member.GetAttribute<FactoryAttribute>() is {} fac
                        && member.TypeDescriptor.DescendsTo(t))
                    {
                        if (member is MemberData && os.Object != null)
                        {
                            ctor = () => (IList)FactoryAttribute.Create(os.Object, fac);
                            return true;
                        }

                        if (member is IParameterMemberData pmem)
                        {
                            ctor = () =>
                            {
                                if (!FactoryAttribute.TryCreateFromMember(pmem, fac, out var o))
                                    throw new Exception(
                                        $"Cannot create object of type '{pmem.TypeDescriptor.Name}' using factory '{fac.FactoryMethodName}'.");
                                if (o is not IList lst)
                                    throw new Exception(
                                        $"Object constructed from factory '{fac.FactoryMethodName}' is not a list.");
                                return lst;
                            };
                            return true;
                        }
                    }

                    ctor = null;
                    return false;
                }


                if (element.IsEmpty)
                {
                    try
                    {
                        var os = Serializer.SerializerStack
                            .OfType<ObjectSerializer>()
                            .FirstOrDefault();
                        if (!_t.CanCreateInstance && !t.IsArray && tryGetFactory(out var f))
                        {
                            setResult(f());
                        }
                        else if (t.IsArray)
                        {
                            setResult(Array.CreateInstance(t.GetElementType(), 0));
                        }
                        else if (t.IsInterface)
                        {
                            setResult(null);
                        }
                        else
                        {
                            setResult(Activator.CreateInstance(t));
                        }

                        return true;
                    }
                    catch (MemberAccessException)
                    {
                        // No or private zero-arg constructor.
                        // Cannot create instance - let it be null.
                    }

                    return false;
                }
                
                IEnumerable values = null;
                
                if (genericType.IsNumeric() && element.HasElements == false)
                {
                    var str = element.Value;
                    var parser = new NumberFormatter(CultureInfo.InvariantCulture);
                    var values2 = parser.Parse(str);
                    finalValues = values2.CastTo(genericType);
                    if (t == typeof(IEnumerable<>).MakeGenericType(genericType)
                        || finalValues.GetType() == t)
                    {
                        setResult(finalValues);
                        return true;
                    }
                }
                
                {
                    if (!_t.CanCreateInstance && !t.IsArray)
                    {
                        var os = Serializer.SerializerStack.OfType<ObjectSerializer>().FirstOrDefault();
                        var mem = os?.CurrentMember;
                        if (mem == null) throw new Exception("Unable to get member list");
                        /* First check if there is a factory we can use. */
                        if (tryGetFactory(out var f))
                        {
                            values = f();
                            this.Object = values;
                        } 
                        else /* otherwise try to update in place */
                        {
                            // the data has to be updated in-place.
                            var val = ((IEnumerable)mem.GetValue(os.Object)).Cast<object>();
                            var elems = element.Elements();
                            if (elems.Count() != val.Count())
                            {
                                Log.Warning("Deserialized unbalanced list.");
                            }

                            foreach (var (elem, obj) in elems.Pairwise(val))
                            {
                                if (!os.TryDeserializeObject(elem, TypeData.GetTypeData(obj), o => { }, obj, true))
                                    return false;
                            }

                            return true;
                        }
                    }

                    if(this.Object != values)
                        this.Object = finalValues;
                    if (finalValues is ICombinedNumberSequence seq)
                        finalValues = seq.Cast<object>().ToArray();
                    var vals = (IList) finalValues;
                    foreach (var node2 in element.Elements())
                    {
                        try
                        {
                            int index = vals.Count;
                            vals.Add(null);
                            if (node2.IsEmpty == false || node2.HasAttributes) // Assuming that null is allowed.
                            {
                                if (!Serializer.Deserialize(node2, x => vals[index] = x, t: genericType))
                                    // Serialization of an element failed, so remove the placeholder.
                                    vals.RemoveAt(vals.Count - 1);
                            }
                        }
                        catch (Exception e)
                        {
                            vals.RemoveAt(vals.Count - 1);
                            Log.Error(e.Message);
                            Log.Debug(e);
                            continue;
                        }
                    }
                }

                
                if (t.IsArray)
                {
                    int elementCount = finalValues.Cast<object>().Count();
                    values = (IList) Activator.CreateInstance(t, elementCount);
                    Serializer.DeferLoad(() =>
                    {
                        // Previous deserialization might have been deferred, so we have to defer again.
                        var lst = (IList) values;
                        int i = 0;
                        foreach (var item in finalValues)
                            lst[i++] = item;
                        setResult(values);
                    });
                }
                else if (!_t.CanCreateInstance && !t.IsArray && tryGetFactory(out _))
                {
                    var lst = (IList)values;
                    foreach (var item in finalValues)
                        lst.Add(item);
                    values = lst;
                }
                else if (t.DescendsTo(typeof(System.Collections.ObjectModel.ReadOnlyCollection<>)))
                {
                    var lst = (IList) Activator.CreateInstance(typeof(List<>).MakeGenericType(genericType));
                    foreach (var item in finalValues)
                        lst.Add(item);
                    values = (IList) Activator.CreateInstance(t, lst);
                }
                else if (t.HasInterface<IList>())
                {
                    if (finalValues.GetType() == t)
                    {
                        values = (IList) finalValues;
                    }
                    else
                    {
                        values = (IList) Activator.CreateInstance(t);
                        if (values is ComponentSettings)
                        {
                            // ComponentSettings must be loaded now.
                            foreach (var item in finalValues)
                                ((IList) values).Add(item);
                        }
                        else
                        {
                            foreach (var val in finalValues)
                                ((IList) values).Add(val);
                        }
                    }
                }
                else if (finalValues is IList lst)
                {
                    values = lst;
                }
                else if (finalValues is IEnumerable en)
                {
                    var lst2 = new List<object>();
                    foreach (var value in en.Cast<object>())
                        lst2.Add(value);
                    values = lst2;
                }
                else
                {
                    throw new Exception("Unable to deserialize list");
                }

                if (values.GetType().DescendsTo(t) == false)
                {
                    try
                    {
                        dynamic newvalues = Activator.CreateInstance(t);
                        if (newvalues is IDictionary)
                        {
                            foreach (dynamic x in values)
                                newvalues.Add(x.Key, x.Value); // x is KeyValuePair.
                        }
                        else
                        {
                            foreach (dynamic x in values)
                                newvalues.Add(x);
                        }

                        values = newvalues;
                    }
                    catch (Exception)
                    {
                        Log.Warning(element, "Unable to deserialize enumerable type '{0}'", t.Name);
                    }
                }

                setResult(values);
                return true;
            }
            finally
            {
                this.Object = prevobj;
                CurrentElementType = prevElementType;
            }
        }

        static readonly XName Element = "Element"; 
        
        internal HashSet<object> ComponentSettingsSerializing = new HashSet<object>();
        /// <summary> Serialization implementation. </summary>
        public override bool Serialize( XElement elem, object sourceObj, ITypeData expectedType)
        {
            if (sourceObj is IEnumerable == false || sourceObj is string) return false;
            IEnumerable sourceEnumerable = (IEnumerable)sourceObj;
            Type type = sourceObj.GetType();
            Type genericTypeArg = type.GetEnumerableElementType();
            if (genericTypeArg == null)
                return false;
            if (genericTypeArg.IsNumeric())
            {
                var parser = new NumberFormatter(CultureInfo.InvariantCulture) {UseRanges = false};
                elem.Value = parser.FormatRange(sourceEnumerable);
                return true;
            }

            object prevObj = this.Object;
            try
            {
                this.Object = sourceObj;
                bool isComponentSettings = sourceObj is ComponentSettings;
                foreach (object obj in sourceEnumerable)
                {
                    var step = new XElement(Element);
                    // We need to add the step to the document immediately so each serializer call 
                    // has access to the element's parents.
                    elem.Add(step);

                    if (obj != null)
                    {
                        type = obj.GetType();
                        step.Name = TapSerializer.TypeToXmlString(type);
                        if (isComponentSettings)
                            ComponentSettingsSerializing.Add(obj);
                        try
                        {
                            Serializer.Serialize(step, obj, expectedType: TypeData.FromType(genericTypeArg));
                        }
                        catch
                        {
                            // Remove the element from the document in case serialization fails
                            step.Remove();
                            throw;
                        }
                        finally
                        {
                            if (isComponentSettings)
                                ComponentSettingsSerializing.Remove(obj);
                        }
                    }

                }
            }
            finally
            {
                this.Object = prevObj;
            }

            return true;
        }

        public object Object { get; private set; }

        public IMemberData CurrentMember => null;
    }

}