using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;

namespace SmallInjector
{
    /// <summary>
    /// A small dependency injector to demonstrate the pattern.
    /// </summary>
    public class Container : IContainer
    {
        private readonly Dictionary<Type, List<RegisteredType>> _container = new Dictionary<Type, List<RegisteredType>>();

        /// <inheritdoc/>
        public void RegisterType<TService, TInterface>(bool isSingleton, TService instance = default)
            where TService : TInterface
        {
            if (!IsRegistered<TInterface>())
            {
                _container[typeof(TInterface)] = new List<RegisteredType>
                    {new RegisteredType(typeof(TService), isSingleton, null)};
            }
            else
            {
                _container[typeof(TInterface)].Add(new RegisteredType(typeof(TService), isSingleton, null));
            }
        }

        /// <inheritdoc/>
        public void RegisterType<TService>(bool isSingleton, TService instance = default) =>
            RegisterType<TService, TService>(isSingleton, instance);

        /// <inheritdoc/>
        public TService Resolve<TService>() => (TService) Resolve(typeof(TService));

        /// <inheritdoc />
        public bool IsRegistered<TService>() => IsRegistered(typeof(TService));

        /// <inheritdoc />
        public bool IsRegistered(Type serviceType) => _container.ContainsKey(serviceType);

        /// <inheritdoc />
        public IEnumerable<object> ResolveAny(Type serviceType)
        {
            if (!_container.TryGetValue(serviceType, out var registeredTypes))
                throw new Exception($"Dependency {serviceType.FullName} is not registered");
            foreach (var registeredType in registeredTypes)
            {
                if (registeredType.IsSingleton && registeredType.Instance != null)
                {
                    yield return registeredType.Instance;
                    continue;
                }

                var constructor = registeredType.ServiceType.GetConstructors()[0];
                var parameters = constructor.GetParameters();
                var constructorParameters = new object[parameters.Length];
                for (var i = 0; i < parameters.Length; i++)
                {
                    var parameterType = parameters[i].ParameterType;
                    if (typeof(Array).IsAssignableFrom(parameterType))
                    {
                            constructorParameters[i] = ResolveAny(parameterType.GetElementType()).ToArray();
                    }
                    else
                    {
                        constructorParameters[i] = Resolve(parameters[i].ParameterType);
                    }
                }

                var instance = constructor.Invoke(constructorParameters);
                yield return registeredType.IsSingleton ? (registeredType.Instance = instance) : instance;
            }
        }

        /// <inheritdoc />
        public IEnumerable<object> ResolveAny<TService>() => ResolveAny(typeof(TService));

        /// <inheritdoc/>
        public object Resolve(Type serviceType) => ResolveAny(serviceType).First();

        private class RegisteredType
        {
            public bool IsSingleton { get; }
            public Type ServiceType { get; }
            public object Instance { get; set; }

            public RegisteredType(Type serviceType, bool isSingleton, object instance)
            {
                ServiceType = serviceType;
                IsSingleton = isSingleton;
                Instance = instance;
            }

            public override string ToString() => ServiceType.ToString();
        }
    }
}