using Autofac;
using Autofac.Core;
using MAX.Core.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Store.Framework.DependencyInjection;

internal class ServiceRegistrarProxy : IServiceRegistrar
{
	private readonly ContainerBuilder _services;

	public object Services => _services;

	public ServiceRegistrarProxy(ContainerBuilder builder)
	{
		_services = builder ?? throw new ArgumentNullException(nameof(builder));
	}

	// ---------------- Scoped ----------------

	public void RegisterScoped<TService>(Func<IServiceProvider, TService> factory)
		where TService : class
	{
		_services.Register(c => factory(c.Resolve<IServiceProvider>()))
				 .As<TService>()
				 .InstancePerLifetimeScope();
	}

	public void RegisterScoped<TService>(object? serviceKey,
		Func<IServiceProvider, object?, TService> factory)
		where TService : class
	{
		_services.Register(c => factory(c.Resolve<IServiceProvider>(), serviceKey))
				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
				 .InstancePerLifetimeScope();
	}

	void IServiceRegistrar.RegisterScoped<TService, TImplementation>()
	{
		_services.RegisterType<TImplementation>()
				 .As<TService>()
				 .InstancePerLifetimeScope();
	}

	void IServiceRegistrar.RegisterScoped<TService, TImplementation>(object? serviceKey)
	{
		_services.RegisterType<TImplementation>()
				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
				 .InstancePerLifetimeScope();
	}

	// ---------------- Singleton ----------------

	public void RegisterSingleton<TService>(TService instance)
		where TService : class
	{
		_services.RegisterInstance(instance)
				 .As<TService>()
				 .SingleInstance();
	}

	public void RegisterSingleton<TService>(Func<IServiceProvider, TService> factory)
		where TService : class
	{
		_services.Register(c => factory(c.Resolve<IServiceProvider>()))
				 .As<TService>()
				 .SingleInstance();
	}

	public void RegisterSingleton<TService>(object? serviceKey, TService instance)
		where TService : class
	{
		_services.RegisterInstance(instance)
				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
				 .SingleInstance();
	}

	public void RegisterSingleton<TService>(object? serviceKey,
		Func<IServiceProvider, object?, TService> factory)
		where TService : class
	{
		_services.Register(c => factory(c.Resolve<IServiceProvider>(), serviceKey))
				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
				 .SingleInstance();
	}

	void IServiceRegistrar.RegisterSingleton<TService, TImplementation>()
	{
		_services.RegisterType<TImplementation>()
				 .As<TService>()
				 .SingleInstance();
	}

	void IServiceRegistrar.RegisterSingleton<TService, TImplementation>(object? serviceKey)
	{
		_services.RegisterType<TImplementation>()
				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
				 .SingleInstance();
	}

	// ---------------- Transient ----------------

	public void RegisterTransient<TService>(Func<IServiceProvider, TService> factory)
		where TService : class
	{
		_services.Register(c => factory(c.Resolve<IServiceProvider>()))
				 .As<TService>()
				 .InstancePerDependency();
	}

	public void RegisterTransient<TService>(object? serviceKey,
		Func<IServiceProvider, object?, TService> factory)
		where TService : class
	{
		_services.Register(c => factory(c.Resolve<IServiceProvider>(), serviceKey))
				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
				 .InstancePerDependency();
	}

	void IServiceRegistrar.RegisterTransient<TService, TImplementation>()
	{
		_services.RegisterType<TImplementation>()
				 .As<TService>()
				 .InstancePerDependency();
	}

	void IServiceRegistrar.RegisterTransient<TService, TImplementation>(object? serviceKey)
	{
		_services.RegisterType<TImplementation>()
				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
				 .InstancePerDependency();
	}
}