using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Tango.Core.DI
{
    /// <summary>
    /// Represents the default Tango IOC container.
    /// </summary>
    /// <seealso cref="Tango.Core.DI.ITangoIOC" />
    public class TangoIOC : ExtendedObject, ITangoIOC
    {
        private class RegisteredType
        {
            public Type InterfaceType { get; set; }
            public Type ImplementationType { get; set; }
            public Object Instance { get; set; }

            public RegisteredType(Type interfaceType, Type implementationType, Object instance)
            {
                InterfaceType = interfaceType;
                ImplementationType = implementationType;
                Instance = instance;
            }
        }

        private static TangoIOC _default;
        /// <summary>
        /// Gets the default Tango IOC container instance.
        /// </summary>
        public static TangoIOC Default
        {
            get
            {
                if (_default == null)
                {
                    _default = new TangoIOC();
                }

                return _default;
            }
        }

        private Dictionary<Type, RegisteredType> _registeredTypes;
        private List<Tuple<Type, Action<Object>>> _waitingRetrivals;

        /// <summary>
        /// Gets or sets a value indicating whether to throw an exception when a type is requested but not registered.
        /// </summary>
        public bool ThrowOnRequestedTypeNotFound { get; set; } = true;

        /// <summary>
        /// Initializes a new instance of the <see cref="TangoIOC"/> class.
        /// </summary>
        public TangoIOC()
        {
            _registeredTypes = new Dictionary<Type, RegisteredType>();
            _waitingRetrivals = new List<Tuple<Type, Action<object>>>();
        }

        /// <summary>
        /// Registers the specified type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public void Register<T>() where T : class
        {
            RegisterInternal(typeof(T), typeof(T), null);
        }

        /// <summary>
        /// Registers the specified instance type and instance.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="instance">The instance.</param>
        public void Register<T>(T instance) where T : class
        {
            RegisterInternal(typeof(T), instance.GetType(), instance);
        }

        /// <summary>
        /// Registers the specified type.
        /// </summary>
        /// <param name="type">The type.</param>
        public void Register(Type type)
        {
            RegisterInternal(type, type, null);
        }

        /// <summary>
        /// Registers the specified type and implementation type.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="implementation">The implementation.</param>
        public void Register(Type type, Type implementation)
        {
            RegisterInternal(type, implementation.GetType(), null);
        }

        /// <summary>
        /// Registers the specified type and instance.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="instance">The instance.</param>
        public void Register(Type type, Object instance)
        {
            RegisterInternal(type, instance.GetType(), instance);
        }

        /// <summary>
        /// Registers this instance.
        /// </summary>
        /// <typeparam name="Type">The type of the type.</typeparam>
        /// <typeparam name="Implementation">The type of the implementation.</typeparam>
        public void Register<Type, Implementation>() where Implementation : class, Type
        {
            RegisterInternal(typeof(Type), typeof(Implementation), null);
        }

        /// <summary>
        /// Registers the specified type, implementation and implementation instance.
        /// </summary>
        /// <typeparam name="Type">The type of the type.</typeparam>
        /// <typeparam name="Implementation">The type of the implementation.</typeparam>
        /// <param name="instance">The instance.</param>
        public void Register<Type, Implementation>(Implementation instance) where Implementation : class, Type
        {
            RegisterInternal(typeof(Type), typeof(Implementation), instance);
        }

        /// <summary>
        /// Unregisters the specified type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public void Unregister<T>()
        {
            Unregister(typeof(T));
        }

        /// <summary>
        /// Unregisters the specified type.
        /// </summary>
        /// <param name="type">The type.</param>
        public virtual void Unregister(Type type)
        {
            _registeredTypes.Remove(type);
        }

        /// <summary>
        /// Gets the instance of type T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T GetInstance<T>()
        {
            return (T)GetInstance(typeof(T));
        }

        /// <summary>
        /// Notifies the awaiting retrievals of a new instance available.
        /// </summary>
        /// <param name="registeredType">Type of the registered.</param>
        private void NotifyAwaitingRetrievals(RegisteredType registeredType)
        {
            var toNotify = _waitingRetrivals.Where(x => x.Item1 == registeredType.InterfaceType).ToList();
            toNotify.ForEach(x => x.Item2(registeredType.Instance));
            _waitingRetrivals.RemoveAll(x => toNotify.Contains(x));
        }

        /// <summary>
        /// Gets the instance by the specified type.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns></returns>
        /// <exception cref="System.InvalidOperationException">The type specified could not be located!</exception>
        public virtual object GetInstance(Type type)
        {
            RegisteredType registeredType = null;

            if (_registeredTypes.TryGetValue(type, out registeredType))
            {
                if (registeredType.Instance == null)
                {
                    registeredType.Instance = CreateInstance(registeredType.ImplementationType);
                    NotifyAwaitingRetrievals(registeredType);
                }

                return registeredType.Instance;
            }
            else
            {
                //Try get by inherited..
                registeredType = _registeredTypes.Select(x => x.Value).SingleOrDefault(x => type.IsAssignableFrom(x.InterfaceType));

                if (registeredType != null)
                {
                    if (registeredType.Instance == null)
                    {
                        registeredType.Instance = CreateInstance(registeredType.ImplementationType);
                        NotifyAwaitingRetrievals(registeredType);
                    }

                    return registeredType.Instance;
                }

                if (!DesignMode && ThrowOnRequestedTypeNotFound)
                {
                    throw new InvalidOperationException(String.Format("Requested type '{0}' could not be found.", type.Name));
                }
                else
                {
                    return null;
                }
            }
        }

        /// <summary>
        /// Executes the specified action when type T is available. if already available action will be executed immediately.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="callback">The callback.</param>
        /// <returns></returns>
        public void GetInstanceWhenAvailable<T>(Action<T> callback)
        {
            GetInstanceWhenAvailable(typeof(T), (x) => callback((T)x));
        }

        /// <summary>
        /// Executes the specified action when type T is available. if already available action will be executed immediately.
        /// </summary>
        /// <param name="callback">The callback.</param>
        /// <returns></returns>
        public virtual void GetInstanceWhenAvailable(Type type, Action<object> callback)
        {
            RegisteredType registeredType = null;

            if (_registeredTypes.TryGetValue(type, out registeredType))
            {
                if (registeredType.Instance != null)
                {
                    callback(registeredType.Instance);
                    return;
                }
            }
            else
            {
                //Try get by inherited..
                registeredType = _registeredTypes.Select(x => x.Value).SingleOrDefault(x => type.IsAssignableFrom(x.InterfaceType));

                if (registeredType != null)
                {
                    if (registeredType.Instance != null)
                    {
                        callback(registeredType.Instance);
                        return;
                    }
                }
            }

            _waitingRetrivals.Add(new Tuple<Type, Action<object>>(type, callback));
        }

        /// <summary>
        /// Determines whether the specified type is registered.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns>
        ///   <c>true</c> if this instance is registered; otherwise, <c>false</c>.
        /// </returns>
        public bool IsRegistered<T>()
        {
            return IsRegistered(typeof(T));
        }

        /// <summary>
        /// Determines whether the specified type is registered.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns>
        ///   <c>true</c> if the specified type is registered; otherwise, <c>false</c>.
        /// </returns>
        public virtual bool IsRegistered(Type type)
        {
            return _registeredTypes.ContainsKey(type);
        }

        /// <summary>
        /// Registers the internal.
        /// </summary>
        /// <param name="interfaceType">Type of the interface.</param>
        /// <param name="implementationType">Type of the implementation.</param>
        /// <param name="instance">The instance.</param>
        protected virtual void RegisterInternal(Type interfaceType, Type implementationType, Object instance)
        {
            if (DesignMode)
            {
                return;
            }

            if (!interfaceType.IsAssignableFrom(implementationType))
            {
                throw new InvalidOperationException(String.Format("Interface type '{0}' cannot be assigned from implementation type '{1}'.", interfaceType.Name, implementationType.Name));
            }

            if (IsRegistered(interfaceType))
            {
                throw new InvalidOperationException(String.Format("The specified type '{0}' is already registered.", interfaceType.Name));
            }

            if (instance != null && instance.GetType() != implementationType)
            {
                throw new InvalidOperationException(String.Format("Instance type '{0}' does not match the implementation type '{1}'.", instance.GetType().Name, implementationType.Name));
            }


            var registeredType = new RegisteredType(interfaceType, implementationType, instance);
            _registeredTypes.Add(interfaceType, registeredType);

            if (implementationType.GetCustomAttribute<TangoCreateWhenRegisteredAttribute>() != null && instance == null)
            {
                instance = GetInstance(interfaceType);
            }

            if (registeredType.Instance != null)
            {
                NotifyAwaitingRetrievals(registeredType);
            }
        }

        /// <summary>
        /// Initializes the instance.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns></returns>
        protected virtual object CreateInstance(Type type)
        {
            List<object> arguments = new List<object>();

            ConstructorInfo constructor = null;

            constructor = type.GetConstructors().FirstOrDefault(x => x.GetCustomAttribute<TangoInjectAttribute>() != null);

            if (constructor == null)
            {
                constructor = type.GetConstructors().FirstOrDefault(x => x.GetParameters().Count() > 0);
            }

            object instance = null;

            if (constructor != null)
            {
                foreach (var arg in constructor.GetParameters())
                {
                    arguments.Add(GetInstance(arg.ParameterType));
                }

                instance = Activator.CreateInstance(type, arguments.ToArray());
            }
            else
            {
                instance = Activator.CreateInstance(type);
            }

            Inject(instance);

            return instance;
        }

        /// <summary>
        /// Gets all instances by the specified base type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public IEnumerable<T> GetAllInstancesByBase<T>()
        {
            return GetAllInstancesByBase(typeof(T)).Select(x => (T)x);
        }

        /// <summary>
        /// Gets all instances by the specified base type.
        /// </summary>
        /// <param name="baseType">Type of the base.</param>
        /// <returns></returns>
        public virtual IEnumerable<object> GetAllInstancesByBase(Type baseType)
        {
            return _registeredTypes.Where(x => baseType.IsAssignableFrom(x.Key)).Select(x => x.Value.Instance != null ? x.Value.Instance : GetInstance(x.Value.ImplementationType));
        }

        /// <summary>
        /// Injects any dependencies to the target properties using the <see cref="TangoInjectAttribute" />.
        /// </summary>
        /// <param name="target">The target.</param>
        public void Inject(object target)
        {
            var type = target.GetType();

            foreach (var prop in type.GetPropertiesWithAttribute<TangoInjectAttribute>(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic))
            {
                var att = prop.GetCustomAttribute<TangoInjectAttribute>();

                if (att.Mode == TangoInjectMode.Immediate)
                {
                    prop.SetValue(target, GetInstance(prop.PropertyType));
                }
                else
                {
                    GetInstanceWhenAvailable(prop.PropertyType, (x) =>
                    {
                        prop.SetValue(target, GetInstance(prop.PropertyType));
                    });
                }
            }

            foreach (var field in type.GetFieldsWithAttribute<TangoInjectAttribute>(BindingFlags.NonPublic | BindingFlags.Instance))
            {
                var att = field.GetCustomAttribute<TangoInjectAttribute>();

                if (att.Mode == TangoInjectMode.Immediate)
                {
                    field.SetValue(target, GetInstance(field.FieldType));
                }
                else
                {
                    GetInstanceWhenAvailable(field.FieldType, (x) =>
                    {
                        field.SetValue(target, GetInstance(field.FieldType));
                    });
                }
            }
        }
    }
}