using System.Collections.Immutable;
using Dpz.Core.SourceGenerator.Models;
using Microsoft.CodeAnalysis;

namespace Dpz.Core.SourceGenerator;

/// <summary>
/// 负责扫描编译结果并生成服务注册元数据。
/// </summary>
internal static class ServiceRegistrationProvider
{
    private const string InterfaceNamespace = "Dpz.Core.Service.RepositoryService";
    private const string ImplementNamespace = "Dpz.Core.Service.RepositoryServiceImpl";
    private const string DependencyInjectionAttributeFullName =
        SourceGeneratorAttributeNames.DependencyInjectionAttributeFullName;
    private const string HttpClientAttributeFullName =
        SourceGeneratorAttributeNames.HttpClientAttributeFullName;

    internal static ImmutableArray<ServiceRegistration> GetRegistrations(
        Compilation compilation,
        SourceProductionContext sourceProductionContext
    )
    {
        var allTypes = new List<INamedTypeSymbol>();
        CollectTypes(compilation.GlobalNamespace, allTypes);

        var interfaces = allTypes
            .Where(type =>
                SymbolEqualityComparer.Default.Equals(type.ContainingAssembly, compilation.Assembly)
                && type.TypeKind == TypeKind.Interface
                && type.ContainingNamespace.ToDisplayString() == InterfaceNamespace
            )
            .OrderBy(type => type.ToDisplayString(), StringComparer.Ordinal)
            .ToList();

        var implementations = allTypes
            .Where(type =>
                SymbolEqualityComparer.Default.Equals(type.ContainingAssembly, compilation.Assembly)
                && type.TypeKind == TypeKind.Class
                && !type.IsAbstract
                && type.ContainingNamespace.ToDisplayString() == ImplementNamespace
            )
            .OrderBy(type => type.ToDisplayString(), StringComparer.Ordinal)
            .ToList();

        var registrations = ImmutableArray.CreateBuilder<ServiceRegistration>();
        foreach (var interfaceType in interfaces)
        {
            if (ShouldIgnore(interfaceType))
            {
                continue;
            }

            var implementationType = implementations.FirstOrDefault(type =>
                type.AllInterfaces.Any(implementedInterface =>
                    SymbolEqualityComparer.Default.Equals(implementedInterface, interfaceType)
                ) || IsConventionImplementation(type, interfaceType)
            );

            if (implementationType is null || ShouldIgnore(implementationType))
            {
                continue;
            }

            registrations.Add(
                CreateRegistration(interfaceType, implementationType, sourceProductionContext)
            );
        }

        return registrations.ToImmutable();
    }

    private static ServiceRegistration CreateRegistration(
        INamedTypeSymbol interfaceType,
        INamedTypeSymbol implementationType,
        SourceProductionContext sourceProductionContext
    )
    {
        var serviceType = SymbolDisplay.ToFullyQualifiedTypeName(interfaceType);
        var implementation = SymbolDisplay.ToFullyQualifiedTypeName(implementationType);
        var implementationNamespace = implementationType.ContainingNamespace.ToDisplayString();
        var cachedMethods = CacheMethodInspector.GetCachedMethods(
            interfaceType,
            implementationType,
            sourceProductionContext
        );
        var invalidatedMethods = CacheMethodInspector.GetInvalidatedMethods(
            interfaceType,
            implementationType,
            cachedMethods,
            sourceProductionContext
        );
        var interfaceMethods = InterfaceContractInspector.GetMethods(interfaceType);
        var interfaceProperties = InterfaceContractInspector.GetProperties(interfaceType);
        var interfaceEvents = InterfaceContractInspector.GetEvents(interfaceType);

        // HttpClient registration is a specialized DI registration. If both attributes are
        // present, HttpClient wins and normal lifetime settings are ignored.
        var httpClientRegistration =
            GetHttpClientRegistration(interfaceType)
            ?? GetHttpClientRegistration(implementationType);
        if (httpClientRegistration is not null)
        {
            return ServiceRegistration.HttpClient(
                serviceType,
                implementation,
                implementationNamespace,
                httpClientRegistration.Value.BaseAddress,
                httpClientRegistration.Value.TimeoutSeconds,
                cachedMethods,
                invalidatedMethods,
                interfaceMethods,
                interfaceProperties,
                interfaceEvents
            );
        }

        return ServiceRegistration.Service(
            serviceType,
            implementation,
            implementationNamespace,
            GetLifetime(implementationType, interfaceType),
            cachedMethods,
            invalidatedMethods,
            interfaceMethods,
            interfaceProperties,
            interfaceEvents
        );
    }

    private static void CollectTypes(INamespaceSymbol namespaceSymbol, List<INamedTypeSymbol> types)
    {
        foreach (var type in namespaceSymbol.GetTypeMembers())
        {
            CollectTypes(type, types);
        }

        foreach (var childNamespace in namespaceSymbol.GetNamespaceMembers())
        {
            CollectTypes(childNamespace, types);
        }
    }

    private static void CollectTypes(INamedTypeSymbol typeSymbol, List<INamedTypeSymbol> types)
    {
        types.Add(typeSymbol);

        foreach (var nestedType in typeSymbol.GetTypeMembers())
        {
            CollectTypes(nestedType, types);
        }
    }

    private static bool ShouldIgnore(INamedTypeSymbol type)
    {
        var attribute = GetAttribute(type, DependencyInjectionAttributeFullName);
        if (attribute is null)
        {
            return false;
        }

        foreach (var namedArgument in attribute.NamedArguments)
        {
            if (namedArgument is { Key: "Ignore", Value.Value: true })
            {
                return true;
            }
        }

        return false;
    }

    private static bool IsConventionImplementation(
        INamedTypeSymbol implementationType,
        INamedTypeSymbol interfaceType
    )
    {
        if (!interfaceType.Name.StartsWith("I", StringComparison.Ordinal))
        {
            return false;
        }

        return string.Equals(
            implementationType.Name,
            interfaceType.Name.Substring(1),
            StringComparison.Ordinal
        );
    }

    private static ServiceLifetime GetLifetime(
        INamedTypeSymbol implementationType,
        INamedTypeSymbol interfaceType
    )
    {
        var attribute =
            GetAttribute(implementationType, DependencyInjectionAttributeFullName)
            ?? GetAttribute(interfaceType, DependencyInjectionAttributeFullName);
        if (attribute?.ConstructorArguments.Length == 1)
        {
            return (ServiceLifetime)(attribute.ConstructorArguments[0].Value as int? ?? 1);
        }

        return ServiceLifetime.Scoped;
    }

    private static HttpClientRegistration? GetHttpClientRegistration(INamedTypeSymbol type)
    {
        var attribute = GetAttribute(type, HttpClientAttributeFullName);
        if (attribute?.ConstructorArguments.Length != 1)
        {
            return null;
        }

        var baseAddress = attribute.ConstructorArguments[0].Value as string;
        if (string.IsNullOrWhiteSpace(baseAddress))
        {
            return null;
        }

        var timeoutSeconds = 0;
        foreach (var namedArgument in attribute.NamedArguments)
        {
            if (
                namedArgument is
                { Key: "TimeoutSeconds", Value.Value: int configuredTimeoutSeconds }
            )
            {
                timeoutSeconds = configuredTimeoutSeconds;
            }
        }

        return new HttpClientRegistration(baseAddress!, timeoutSeconds);
    }

    private static AttributeData? GetAttribute(INamedTypeSymbol type, string attributeFullName)
    {
        return GetAttribute((ISymbol)type, attributeFullName);
    }

    private static AttributeData? GetAttribute(ISymbol symbol, string attributeFullName)
    {
        return symbol
            .GetAttributes()
            .FirstOrDefault(attribute =>
                attribute.AttributeClass?.ToDisplayString() == attributeFullName
            );
    }
}