using System.Reflection;
using Autofac;
using Autofac.Extras.DynamicProxy;
using Castle.DynamicProxy;
using KH.WMS.Core.AOP;
using KH.WMS.Core.DependencyInjection.ServiceLifetimes;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace KH.WMS.Core.DependencyInjection;

/// <summary>
/// 自动服务注册器
/// </summary>
public class ServiceRegistrar : IServiceRegistrar
{
    public void Register(ContainerBuilder builder, params Assembly[] assemblies)
    {
        // 如果没有传入程序集，使用调用程序集
        if (assemblies == null || assemblies.Length == 0)
        {
            assemblies = new[] { Assembly.GetCallingAssembly() };
        }

        // 注册所有带生命周期标记的服务
        RegisterServicesWithLifetime(builder, assemblies);

        Console.WriteLine("服务注册完成");
    }

    private Type[] interceptors = new Type[]
    {
        typeof(LoggingInterceptor),
    };

    private void RegisterServicesWithLifetime(ContainerBuilder builder, Assembly[] assemblies)
    {
        var serviceTypes = new[]
        {
            typeof(RegisteredServiceAttribute),
            typeof(SelfRegisteredServiceAttribute)
        };

        builder.RegisterType<LoggingInterceptor>();

        foreach (var assembly in assemblies)
        {
            var types = assembly.GetTypes()
                .Where(t => t.IsClass && !t.IsAbstract && !t.IsInterface)
                .SelectMany(t => t.GetCustomAttributes(), (t, attr) => new { Type = t, Attribute = attr })
                .Where(x => serviceTypes.Contains(x.Attribute.GetType()));

            foreach (var item in types)
            {
                if (item.Type.Name.Contains("LoggerService"))
                {
                    RegisterServiceWithoutInterceptor(builder, item.Type, item.Attribute, assemblies);
                    continue;
                }

                var interfaces = item.Type.GetInterfaces();
                var serviceType = interfaces.FirstOrDefault() ?? item.Type;

                if (item.Attribute is RegisteredServiceAttribute registeredAttr)
                {
                    if (serviceType == item.Type)
                    {
                        Console.WriteLine($"类型 {item.Type.Name} 标记为 RegisteredServiceAttribute，但未实现任何接口，建议使用 SelfRegisteredServiceAttribute 进行自注册。");
                        Console.WriteLine($"继续注册 {item.Type.Name} 为自注册服务。");

                        RegisterSelfService(builder, item.Type, registeredAttr.Lifetime);
                        continue;
                    }

                    RegisterService(builder, serviceType, item.Type, registeredAttr.Lifetime);
                }
                else if (item.Attribute is SelfRegisteredServiceAttribute selfRegisteredAttr)
                {
                    RegisterSelfService(builder, item.Type, selfRegisteredAttr.Lifetime);
                }
            }
        }
    }

    /// <summary>
    /// 注册服务但不添加拦截器（用于 LoggerService 等基础服务）
    /// </summary>
    private void RegisterServiceWithoutInterceptor(ContainerBuilder builder, Type implementationType, Attribute attribute, Assembly[] assemblies)
    {
        if (attribute is RegisteredServiceAttribute registeredAttr)
        {
            var interfaces = implementationType.GetInterfaces();
            var serviceType = interfaces.FirstOrDefault() ?? implementationType;

            switch (registeredAttr.Lifetime)
            {
                case ServiceLifetime.Singleton:
                    builder.RegisterType(implementationType).As(serviceType).SingleInstance();
                    Console.WriteLine($"注册 Singleton 服务（无拦截器）: {serviceType.Name}");
                    break;
                case ServiceLifetime.Scoped:
                    builder.RegisterType(implementationType).As(serviceType).InstancePerLifetimeScope();
                    Console.WriteLine($"注册 Scoped 服务（无拦截器）: {serviceType.Name}");
                    break;
                case ServiceLifetime.Transient:
                    builder.RegisterType(implementationType).As(serviceType).InstancePerDependency();
                    Console.WriteLine($"注册 Transient 服务（无拦截器）: {serviceType.Name}");
                    break;
            }
        }
        else if (attribute is SelfRegisteredServiceAttribute selfRegisteredAttr)
        {
            switch (selfRegisteredAttr.Lifetime)
            {
                case ServiceLifetime.Singleton:
                    builder.RegisterType(implementationType).SingleInstance();
                    Console.WriteLine($"注册自注册 Singleton 服务（无拦截器）: {implementationType.Name}");
                    break;
                case ServiceLifetime.Scoped:
                    builder.RegisterType(implementationType).InstancePerLifetimeScope();
                    Console.WriteLine($"注册自注册 Scoped 服务（无拦截器）: {implementationType.Name}");
                    break;
                case ServiceLifetime.Transient:
                    builder.RegisterType(implementationType).InstancePerDependency();
                    Console.WriteLine($"注册自注册 Transient 服务（无拦截器）: {implementationType.Name}");
                    break;
            }
        }
    }

    private void RegisterService(ContainerBuilder builder, Type serviceType, Type implementationType, ServiceLifetime lifetime)
    {
        switch (lifetime)
        {
            case ServiceLifetime.Singleton:
                builder.RegisterType(implementationType).As(serviceType).SingleInstance().EnableInterfaceInterceptors().InterceptedBy(interceptors);
                Console.WriteLine($"注册 Singleton 服务: {serviceType.Name}");
                break;
            case ServiceLifetime.Scoped:
                builder.RegisterType(implementationType).As(serviceType).InstancePerLifetimeScope().EnableInterfaceInterceptors().InterceptedBy(interceptors);
                Console.WriteLine($"注册 Scoped 服务: {serviceType.Name}");
                break;
            case ServiceLifetime.Transient:
                builder.RegisterType(implementationType).As(serviceType).InstancePerDependency().EnableInterfaceInterceptors().InterceptedBy(interceptors);
                Console.WriteLine($"注册 Transient 服务: {serviceType.Name}");
                break;
        }
    }

    private void RegisterSelfService(ContainerBuilder builder, Type implementationType, ServiceLifetime lifetime)
    {
        switch (lifetime)
        {
            case ServiceLifetime.Singleton:
                builder.RegisterType(implementationType).SingleInstance().EnableClassInterceptors().InterceptedBy(interceptors);
                Console.WriteLine($"注册自注册 Singleton 服务: {implementationType.Name}");
                break;
            case ServiceLifetime.Scoped:
                builder.RegisterType(implementationType).InstancePerLifetimeScope().EnableClassInterceptors().InterceptedBy(interceptors);
                Console.WriteLine($"注册自注册 Scoped 服务: {implementationType.Name}");
                break;
            case ServiceLifetime.Transient:
                builder.RegisterType(implementationType).InstancePerDependency().EnableClassInterceptors().InterceptedBy(interceptors);
                Console.WriteLine($"注册自注册 Transient 服务: {implementationType.Name}");
                break;
        }
    }
}