using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
namespace Playground
{
    public class SmallInjector
    {
        private readonly Dictionary<Type, RegisteredType> _container = new Dictionary<Type, RegisteredType>();

        public void RegisterType<TService, TInterface>(bool isSingleton)
        {
            _container.Add(typeof(TInterface), new RegisteredType(typeof(TService), isSingleton));
        }

        public void RegisterType<TService>(bool isSingleton) => RegisterType<TService, TService>(isSingleton);

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

        public object Resolve(Type serviceInterface)
        {
            if (!_container.TryGetValue(serviceInterface, out var registeredType))
            {
                throw new Exception("Can't resolve dependency " + serviceInterface);
            }

            if (registeredType.IsSingleton && registeredType.SingletonInstance != null)
                return registeredType.SingletonInstance;
            var constructor = registeredType.ConcreteType.GetConstructors()[0];
            var parameters = constructor.GetParameters();
            var constructorParameters = new object[parameters.Length];
            for (var i = 0; i < parameters.Length; i++)
            {
                constructorParameters[i] = Resolve(parameters[i].ParameterType);
            }

            if (registeredType.IsSingleton)
            {
                return registeredType.SingletonInstance ?? (registeredType.SingletonInstance = constructor.Invoke(constructorParameters));
            }
            return constructor.Invoke(constructorParameters);

        }
    }
}