// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Reflection;
using System.Text;
using Microsoft.Extensions.DependencyInjection;

namespace Microsoft.DotNet.Internal.DependencyInjection.Testing;

public static class DependencyInjectionValidation
{
    private static readonly ImmutableList<string> s_exemptTypes = ImmutableList.Create(
        "System.Fabric.ServiceContext",
        "System.Fabric.StatelessServiceContext",
        "System.Fabric.StatefulServiceContext",
        "Microsoft.DotNet.ServiceFabric.ServiceHost.IServiceLoadReporter",
        "Microsoft.Extensions.Options.IConfigureOptions`1",
        "Microsoft.Extensions.Caching.Memory.MemoryCacheOptions",
        "Microsoft.Extensions.Caching.Memory.MemoryDistributedCacheOptions",
        "Microsoft.Extensions.DependencyInjection.IServiceScopeFactory",
        "System.IServiceProvider"
    );

    private static readonly ImmutableList<string> s_exemptNamespaces = ImmutableList.Create(
        "Microsoft.ApplicationInsights.AspNetCore",
        "Microsoft.AspNetCore"
    );

    public static bool IsDependencyResolutionCoherent(
        Action<ServiceCollection> register,
        out string errorMessage,
        IEnumerable<Type> additionalScopedTypes = null,
        IEnumerable<Type> additionalSingletonTypes = null)
    {
        errorMessage = null;

        StringBuilder allErrors = new StringBuilder();
        allErrors.Append("The following types are not resolvable:");

        var services = new ServiceCollection();

        register(services);

        bool allResolved = true;

        foreach (ServiceDescriptor service in services)
        {
            if (service.ImplementationType == null)
            {
                continue;
            }

            if (IsExemptType(service.ImplementationType) || IsExemptType(service.ServiceType))
            {
                continue;
            }

            if (!IsTypeResolvable(service.ImplementationType, services, allErrors, service.Lifetime))
            {
                allResolved = false;
            }
        }

        foreach (Type scopedType in additionalScopedTypes ?? Enumerable.Empty<Type>())
        {
            if (!IsTypeResolvable(scopedType, services, allErrors, ServiceLifetime.Scoped))
            {
                allResolved = false;
            }
        }

        foreach (Type scopedType in additionalSingletonTypes ?? Enumerable.Empty<Type>())
        {
            if (!IsTypeResolvable(scopedType, services, allErrors, ServiceLifetime.Singleton))
            {
                allResolved = false;
            }
        }

        if (!allResolved)
            errorMessage = allErrors.ToString();

        return allResolved;
    }

    private static bool IsTypeResolvable(
        Type type,
        ServiceCollection services,
        StringBuilder msgBuilder,
        ServiceLifetime serviceLifetime)
    {
        ConstructorInfo[] constructors = type
            .GetConstructors(BindingFlags.Public | BindingFlags.Instance)
            .OrderBy(c => c.GetParameters().Length)
            .ToArray();

        if (constructors.Length == 0)
        {
            // zero constructor things are implicitly constructable
            return true;
        }

        string errorMessage = null;
        foreach (ConstructorInfo ctor in constructors)
        {
            if (IsConstructorResolvable(ctor, services, errorMessage == null, serviceLifetime, out string ctorMsg))
            {
                return true;
            }

            errorMessage ??= ctorMsg;
        }

        msgBuilder.AppendLine();
        msgBuilder.AppendLine();
        msgBuilder.AppendLine(errorMessage);

        return false;
    }

    private static bool IsConstructorResolvable(
        ConstructorInfo ctor,
        ServiceCollection services,
        bool recordErrors,
        ServiceLifetime serviceLifetime,
        out string errorMessage)
    {
        errorMessage = null;
        bool resolvedAllParameters = true;
        StringBuilder msgBuilder = null;
        if (recordErrors)
        {
            msgBuilder = new StringBuilder();
            msgBuilder.Append("Type ");
            msgBuilder.Append(ctor.DeclaringType.FullName);
            msgBuilder.Append(" could not find registered definition for parameter(s): ");
        }

        foreach (ParameterInfo p in ctor.GetParameters())
        {
            ServiceDescriptor parameterService = services.FirstOrDefault(s => IsMatchingServiceRegistration(s.ServiceType, p.ParameterType));
            if (parameterService != null)
            {
                if (serviceLifetime == ServiceLifetime.Singleton &&
                    parameterService.Lifetime == ServiceLifetime.Scoped)
                {
                    if (!resolvedAllParameters)
                    {
                        msgBuilder.Append(", ");
                    }

                    msgBuilder.Append("<SCOPED> ");
                    msgBuilder.Append(p.Name);
                    msgBuilder.Append(" of type ");
                    msgBuilder.Append(GetDisplayName(p.ParameterType));

                    resolvedAllParameters = false;
                }

                continue;
            }

            // Save the first error message, since it's likely to be the most useful
            if (recordErrors)
            {
                if (!resolvedAllParameters)
                {
                    msgBuilder.Append(", ");
                }

                msgBuilder.Append(p.Name);
                msgBuilder.Append(" of type ");
                msgBuilder.Append(GetDisplayName(p.ParameterType));
            }

            resolvedAllParameters = false;
        }

        if (recordErrors && !resolvedAllParameters)
        {
            errorMessage = msgBuilder.ToString();
        }

        return resolvedAllParameters;
    }

    private static string GetDisplayName(Type type)
    {
        if (type.IsConstructedGenericType)
        {
            // The name of IOptions<Pizza> is "IOptions`1"
            // The full name has the other types, but they are all fully qualified (and also still have the `1 on them)
            string baseName = type.Name.Split('`')[0];
            return $"{baseName}<{string.Join(", ", type.GetGenericArguments().Select(GetDisplayName))}>";
        }

        return type.Name;
    }

    private static bool IsMatchingServiceRegistration(Type serviceType, Type parameterType)
    {
        // If it's options, lets make sure they are configured
        if (parameterType.IsConstructedGenericType)
        {
            Type parameterRoot = parameterType.GetGenericTypeDefinition();
            if (IsOptionsType(parameterRoot))
            {
                if (!serviceType.IsConstructedGenericType) return false;

                Type optionType = parameterType.GenericTypeArguments[0];

                if (IsExemptType(optionType))
                    return true;

                Type serviceRoot = serviceType.GetGenericTypeDefinition();
                return serviceRoot.FullName == "Microsoft.Extensions.Options.IConfigureOptions`1" &&
                    serviceType.GenericTypeArguments[0] == optionType;
            }
        }

        if (IsExemptType(parameterType))
        {
            return true;
        }

        if (serviceType == parameterType) return true;
        if (!parameterType.IsConstructedGenericType) return false;
        Type def = parameterType.GetGenericTypeDefinition();
        if (def == typeof(IEnumerable<>))
        {
            // IEnumerable can be zero, and that's fine
            return true;
        }

        return serviceType == def;
    }

    private static bool IsOptionsType(Type parameterRoot)
    {
        switch (parameterRoot.FullName)
        {
            case "Microsoft.Extensions.Options.IOptions`1":
            case "Microsoft.Extensions.Options.IOptionsMonitor`1":
            case "Microsoft.Extensions.Options.IOptionsSnapshot`1":
                return true;
            default:
                return false;
        }
    }

    private static bool IsExemptType(Type type)
    {
        if (type.IsConstructedGenericType)
            return IsExemptType(type.GetGenericTypeDefinition());

        return s_exemptTypes.Contains(type.FullName) || s_exemptNamespaces.Any(n => type.FullName.StartsWith(n));
    }
}