// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System;
using System.Collections.Immutable;
using System.Composition;
using System.Reflection;
using System.Threading;
using Microsoft.CodeAnalysis.ExternalAccess.Extensions;
using Microsoft.CodeAnalysis.Host.Mef;
 
namespace Microsoft.CodeAnalysis.Extensions;
 
[ExportWorkspaceService(typeof(IExtensionMessageHandlerFactory)), Shared]
[method: ImportingConstructor]
[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
internal sealed class ExtensionMessageHandlerFactory() : IExtensionMessageHandlerFactory
{
    public ImmutableArray<IExtensionMessageHandlerWrapper<Document>> CreateDocumentMessageHandlers(
        Assembly assembly, string extensionIdentifier, CancellationToken cancellationToken)
        => CreateWorkspaceHandlers(
            assembly,
            typeof(IExtensionDocumentMessageHandler<,>),
            (handler, handlerInterface) => new ExtensionDocumentMessageHandlerWrapper(handler, handlerInterface, extensionIdentifier),
            cancellationToken);
 
    public ImmutableArray<IExtensionMessageHandlerWrapper<Solution>> CreateWorkspaceMessageHandlers(
        Assembly assembly, string extensionIdentifier, CancellationToken cancellationToken)
        => CreateWorkspaceHandlers(
            assembly,
            typeof(IExtensionWorkspaceMessageHandler<,>),
            (handler, handlerInterface) => new ExtensionWorkspaceMessageHandlerWrapper(handler, handlerInterface, extensionIdentifier),
            cancellationToken);
 
    private static ImmutableArray<IExtensionMessageHandlerWrapper<TArgument>> CreateWorkspaceHandlers<TArgument>(
        Assembly assembly,
        Type unboundInterfaceType,
        Func<object, Type, IExtensionMessageHandlerWrapper<TArgument>> wrapperCreator,
        CancellationToken cancellationToken)
    {
        var resultBuilder = ImmutableArray.CreateBuilder<IExtensionMessageHandlerWrapper<TArgument>>();
 
        foreach (var candidateType in assembly.GetTypes())
        {
            cancellationToken.ThrowIfCancellationRequested();
 
            if (candidateType.IsAbstract || candidateType.IsGenericType)
                continue;
 
            Type? boundInterfaceType = null;
            foreach (var interfaceType in candidateType.GetInterfaces())
            {
                if (interfaceType.IsGenericType &&
                    !interfaceType.IsGenericTypeDefinition &&
                    interfaceType.GetGenericTypeDefinition() == unboundInterfaceType)
                {
                    if (boundInterfaceType is not null)
                        throw new InvalidOperationException(string.Format(ExternalAccessExtensionsResources.Type_0_implements_interface_1_more_than_once, candidateType.FullName, unboundInterfaceType.Name));
 
                    boundInterfaceType = interfaceType;
                }
            }
 
            if (boundInterfaceType == null)
                continue;
 
            var handler = Activator.CreateInstance(candidateType)
                ?? throw new InvalidOperationException(string.Format(ExternalAccessExtensionsResources.Cannot_create_0, candidateType.FullName));
 
            resultBuilder.Add(wrapperCreator(handler, boundInterfaceType));
        }
 
        return resultBuilder.ToImmutable();
    }
}