using LiteDB;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.ActionLogs;
using Tango.BL.ValueObjects;
using Tango.Core.ExtensionMethods;

namespace Tango.BL
{
    /// <summary>
    /// Represents an auto generated observable entity transport object mirror.
    /// </summary>
    /// <typeparam name="DTO">The type of to.</typeparam>
    /// <typeparam name="T"></typeparam>
    /// <seealso cref="Tango.BL.IObservableEntityDTO" />
    /// <seealso cref="System.IEquatable{T}" />
    /// <seealso cref="Tango.BL.ActionLogs.IActionLogComparable{DTO}" />
    public abstract class ObservableEntityDTO<DTO, T> : IObservableEntityDTO, IEquatable<T>, IActionLogComparable where T : IObservableEntity where DTO : ObservableEntityDTO<DTO, T>
    {
        /// <summary>
        /// Gets or sets the ID of the entity.
        /// </summary>
        public int ID { get; set; }

        /// <summary>
        /// Gets or sets the unique identifier of the entity.
        /// </summary>
        [BsonId]
        public String Guid { get; set; }

        /// <summary>
        /// Gets or sets the last updated date of the entity.
        /// </summary>
        public DateTime LastUpdated { get; set; }

        /// <summary>
        /// Creates an instance of type <see cref="DTO"/> for the specified entity of type <see cref="T"/>.
        /// </summary>
        /// <param name="observable">The observable.</param>
        /// <returns></returns>
        public static DTO FromObservable(T observable)
        {
            return FromObservableInternal<DTO>(observable);
        }

        /// <summary>
        /// Creates an instance of type <see cref="DTOResult"/> for the specified entity of type <see cref="T"/>.
        /// </summary>
        /// <param name="observable">The observable.</param>
        /// <returns></returns>
        public static DTOResult FromObservable<DTOResult>(T observable) where DTOResult : DTO
        {
            return FromObservableInternal<DTOResult>(observable);
        }

        internal static DTOResult FromObservableInternal<DTOResult>(T observable) where DTOResult : DTO
        {
            if (observable == null) return null;

            var dto = Activator.CreateInstance<DTOResult>();

            foreach (var prop in typeof(DTOResult).GetProperties())
            {
                var observableProp = typeof(T).GetProperty(prop.Name);
                if (observableProp != null)
                {
                    if (prop.PropertyType.IsValueTypeOrString() || prop.PropertyType == typeof(byte[]))
                    {
                        prop.SetValue(dto, observableProp.GetValue(observable));
                    }
                    else if (!prop.PropertyType.IsGenericType)
                    {
                        prop.SetValue(dto, prop.PropertyType.GetMethod(nameof(FromObservableInternal), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy).MakeGenericMethod(prop.PropertyType).Invoke(null, new object[] { observableProp.GetValue(observable) }));
                    }
                    else
                    {
                        IList collection = Activator.CreateInstance(prop.PropertyType) as IList;
                        IList source = observableProp.GetValue(observable) as IList;

                        foreach (var item in source)
                        {
                            collection.Add(prop.PropertyType.GenericTypeArguments[0].GetMethod(nameof(FromObservableInternal), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy).MakeGenericMethod(prop.PropertyType.GenericTypeArguments[0]).Invoke(null, new object[] { item }));
                        }

                        prop.SetValue(dto, collection);
                    }
                }
                else if (prop.GetCustomAttribute<ObservableDTOPropertyAttribute>() != null)
                {
                    var att = prop.GetCustomAttribute<ObservableDTOPropertyAttribute>();

                    try
                    {
                        prop.SetValue(dto, observable.GetPropertyValueByPath(att.MapsTo));
                    }
                    catch
                    {
                        Debug.WriteLine($"Error mapping '{typeof(DTOResult).Name}.{prop.PropertyType}' to '{typeof(T)}.{att.MapsTo}'.");
                    }
                }
            }

            dto.OnFromObservableCompleted(observable);

            return dto;
        }

        /// <summary>
        /// Creates an entity of type <see cref="T"/> from this DTO.
        /// </summary>
        /// <returns></returns>
        public T ToObservable()
        {
            T observable = Activator.CreateInstance<T>();
            MapToObservable(observable);
            return observable;
        }

        /// <summary>
        /// Maps this instance to an instance of <see cref="T"/>.
        /// </summary>
        /// <param name="observable">The observable.</param>
        public virtual void MapToObservable(T observable)
        {
            foreach (var prop in GetType().GetProperties())
            {
                var observableProp = typeof(T).GetProperty(prop.Name);
                if (observableProp != null)
                {
                    if (prop.PropertyType.IsValueTypeOrString() || prop.PropertyType == typeof(byte[]))
                    {
                        observableProp.SetValue(observable, prop.GetValue(this));
                    }
                    else if (!prop.PropertyType.IsGenericType)
                    {
                        var propInstance = prop.GetValue(this);

                        if (propInstance != null)
                        {
                            var observableInstance = observableProp.GetValue(observable);

                            if (observableInstance == null)
                            {
                                observableInstance = Activator.CreateInstance(observableProp.PropertyType);
                                observableProp.SetValue(observable, observableInstance);
                            }

                            var method = prop.PropertyType.GetRuntimeMethod(nameof(MapToObservable), new Type[] { observableProp.PropertyType });
                            method.Invoke(propInstance, new object[] { observableInstance });
                        }
                    }
                    else
                    {
                        IList collection = prop.GetValue(this) as IList;
                        IList observableCollection = observableProp.GetValue(observable) as IList;

                        if (collection != null)
                        {
                            foreach (var item in collection)
                            {
                                bool found = false;

                                foreach (var o in observableCollection)
                                {
                                    var dtoItem = item as IObservableEntityDTO;
                                    var observableItem = o as IObservableEntity;

                                    if (dtoItem.Guid.Equals(observableItem.Guid))
                                    {
                                        var method = dtoItem.GetType().GetRuntimeMethod(nameof(MapToObservable), new Type[] { observableItem.GetType() });
                                        method.Invoke(dtoItem, new object[] { observableItem });
                                        found = true;
                                        break;
                                    }
                                }

                                if (!found)
                                {
                                    var observableItem = Activator.CreateInstance(observableProp.PropertyType.GenericTypeArguments[0]);
                                    var method = item.GetType().GetRuntimeMethod(nameof(MapToObservable), new Type[] { observableItem.GetType() });
                                    method.Invoke(item, new object[] { observableItem });
                                    observableCollection.Add(observableItem);
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Returns true if this instance is equal in terms of values (not references) to the specified entity.
        /// </summary>
        /// <param name="observable">The observable.</param>
        /// <returns></returns>
        public bool EqualsToObservable(T observable)
        {
            if (observable == null) return false;

            foreach (var prop in typeof(DTO).GetProperties())
            {
                var observableProp = typeof(T).GetProperty(prop.Name);
                if (observableProp != null)
                {
                    if (prop.PropertyType.IsValueTypeOrString() || prop.PropertyType == typeof(byte[]))
                    {
                        var observableValue = observableProp.GetValue(observable);
                        var dtoValue = prop.GetValue(this);

                        if (dtoValue == null && observableValue != null) return false;
                        if (dtoValue != null && observableValue == null) return false;

                        if (dtoValue != null && observableValue != null)
                        {
                            if (!dtoValue.Equals(observableValue))
                            {
                                return false;
                            }
                        }
                    }
                    else if (!prop.PropertyType.IsGenericType)
                    {
                        var propInstance = prop.GetValue(this);
                        var observableInstance = observableProp.GetValue(observable);
                        if (propInstance == null && observableInstance != null) return false;

                        if (propInstance != null)
                        {
                            var method = prop.PropertyType.GetRuntimeMethod(nameof(EqualsToObservable), new Type[] { observableInstance.GetType() });

                            if (!((bool)method.Invoke(propInstance, new object[] { observableInstance })))
                            {
                                return false;
                            }
                        }
                    }
                    else
                    {
                        IList source = observableProp.GetValue(observable) as IList;
                        IList collection = prop.GetValue(this) as IList;

                        if (collection == null && source != null) return false;
                        if (source == null && collection != null) return false;

                        if (source != null && collection != null)
                        {
                            if (source.Count != collection.Count) return false;

                            for (int i = 0; i < source.Count; i++)
                            {
                                var item = collection[i];
                                var itemSource = source[i];

                                var method = item.GetType().GetRuntimeMethod(nameof(EqualsToObservable), new Type[] { itemSource.GetType() });

                                if (item == null && itemSource != null) return false;

                                if (!((bool)method.Invoke(item, new object[] { itemSource })))
                                {
                                    return false;
                                }
                            }
                        }
                    }
                }
            }

            return true;
        }

        /// <summary>
        /// Returns true if this instance is equal in terms of values (not references) to the specified entity.
        /// </summary>
        /// <param name="observable">The observable.</param>
        /// <returns></returns>
        public bool Equals(T observable)
        {
            return EqualsToObservable(observable);
        }

        /// <summary>
        /// Returns true if the specified property should be ignored during ActionLog comparison.
        /// </summary>
        /// <param name="propName">Name of the property.</param>
        /// <returns></returns>
        bool IActionLogComparable.ShouldActionLogIgnore(string propName)
        {
            return propName == nameof(LastUpdated) || OnShouldActionLogIgnore(propName);
        }

        /// <summary>
        /// override to specified properties to be ignored when doing ActionLog comparison.
        /// </summary>
        /// <param name="propName">Name of the property.</param>
        /// <returns></returns>
        protected virtual bool OnShouldActionLogIgnore(string propName)
        {
            return false;
        }

        /// <summary>
        /// Returns an optional custom name for this instance in the comparison tree.
        /// </summary>
        /// <returns></returns>
        string IActionLogComparable.GetActionLogName()
        {
            return OnGetActionLogName();
        }

        /// <summary>
        /// override to specified a custom name for this instance in the ActionLog comparison tree.
        /// </summary>
        /// <returns></returns>
        protected virtual String OnGetActionLogName()
        {
            return this.GetType().Name;
        }

        /// <summary>
        /// Called when the static method <see cref="FromObservable(T)"/> completes.
        /// </summary>
        /// <param name="observable">The observable.</param>
        protected virtual void OnFromObservableCompleted(T observable)
        {
            //Just for override
        }
    }
}