// 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.Generic;
using System.Collections.Immutable;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Text;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CodeRefactorings;
using Microsoft.CodeAnalysis.Test.Utilities;
using Microsoft.VisualStudio.Composition;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 
[UseExportProvider]
public class CodeChangeProviderMetadataTests
{
    [Theory]
    [InlineData(typeof(CodeFixProvider))]
    [InlineData(typeof(CodeRefactoringProvider))]
    [InlineData(typeof(IConfigurationFixProvider))]
    public void TestNameMetadataIsPresent(Type providerType)
    {
        var configuration = EditorTestCompositions.EditorFeatures.GetCompositionConfiguration();
        var exportedProviders = FindComposedPartsWithExport(configuration, providerType.FullName).ToArray();
 
        var failureMessage = new StringBuilder();
        failureMessage.AppendLine($"The following {providerType.Name}s exported without Name metadata:");
        var passLength = failureMessage.Length;
 
        foreach (var (providerPart, providerExport) in exportedProviders)
        {
            if (!TryGetExportName(providerExport, out var _))
            {
                failureMessage.AppendLine(providerPart.Definition.Type.FullName);
            }
        }
 
        Assert.True(failureMessage.Length == passLength, failureMessage.ToString());
    }
 
    [Theory]
    [InlineData(typeof(CodeFixProvider), LanguageNames.CSharp)]
    [InlineData(typeof(CodeFixProvider), LanguageNames.VisualBasic)]
    [InlineData(typeof(CodeRefactoringProvider), LanguageNames.CSharp)]
    [InlineData(typeof(CodeRefactoringProvider), LanguageNames.VisualBasic)]
    [InlineData(typeof(IConfigurationFixProvider), LanguageNames.CSharp)]
    [InlineData(typeof(IConfigurationFixProvider), LanguageNames.VisualBasic)]
    public void TestNameMetadataIsUniqueAmongProviders(Type providerType, string language)
    {
        var configuration = EditorTestCompositions.EditorFeatures.GetCompositionConfiguration();
        var exportedProviders = FindComposedPartsWithExportForLanguage(configuration, providerType.FullName, language);
 
        var failureMessage = new StringBuilder();
        failureMessage.AppendLine($"The following {providerType.Name}s are exported for {language} without unique Name metadata:");
        var passLength = failureMessage.Length;
 
        var exportedProvidersByName = exportedProviders.GroupBy(
            exportedProvider => TryGetExportName(exportedProvider.Export, out var name) ? name : string.Empty);
 
        foreach (var namedGroup in exportedProvidersByName)
        {
            if (string.IsNullOrEmpty(namedGroup.Key))
            {
                continue;
            }
 
            if (namedGroup.Count() == 1)
            {
                continue;
            }
 
            var providerNames = string.Join(", ", namedGroup.Select(exportedProvider => exportedProvider.Part.Definition.Type.FullName));
            failureMessage.AppendLine($"'{namedGroup.Key}' is used by the following providers: {providerNames}");
        }
 
        Assert.True(failureMessage.Length == passLength, failureMessage.ToString());
    }
 
    [Theory]
    [InlineData(typeof(CodeFixProvider), typeof(PredefinedCodeFixProviderNames))]
    [InlineData(typeof(CodeRefactoringProvider), typeof(PredefinedCodeRefactoringProviderNames))]
    [InlineData(typeof(IConfigurationFixProvider), typeof(PredefinedConfigurationFixProviderNames))]
    public void TestNameMetadataIsInPredefinedNames(Type providerType, Type predefinedNamesType)
    {
        var predefinedNames = GetPredefinedNamesFromType(predefinedNamesType);
 
        var configuration = EditorTestCompositions.EditorFeatures.GetCompositionConfiguration();
        var exportedProviders = FindComposedPartsWithExport(configuration, providerType.FullName).ToArray();
 
        var failureMessage = new StringBuilder();
        failureMessage.AppendLine($"The following providers were exported with a Name not present in Predefined{providerType.Name}Names:");
        var passLength = failureMessage.Length;
 
        foreach (var (providerPart, providerExport) in exportedProviders)
        {
            if (TryGetExportName(providerExport, out var name)
                && !predefinedNames.Contains(name))
            {
                failureMessage.AppendLine(providerPart.Definition.Type.FullName);
            }
        }
 
        Assert.True(failureMessage.Length == passLength, failureMessage.ToString());
    }
 
    [Theory]
    [InlineData(typeof(CodeFixProvider), typeof(PredefinedCodeFixProviderNames))]
    [InlineData(typeof(CodeRefactoringProvider), typeof(PredefinedCodeRefactoringProviderNames))]
    [InlineData(typeof(IConfigurationFixProvider), typeof(PredefinedConfigurationFixProviderNames))]
    public void TestAllPredefinedNamesUsedAsNameMetadata(Type providerType, Type predefinedNamesType)
    {
        var predefinedNames = GetPredefinedNamesFromType(predefinedNamesType);
 
        var configuration = EditorTestCompositions.EditorFeatures.GetCompositionConfiguration();
        var exportedProviders = FindComposedPartsWithExport(configuration, providerType.FullName);
        var providerNames = exportedProviders
            .Select(exportedProvider => TryGetExportName(exportedProvider.Export, out var name) ? name : string.Empty)
            .ToImmutableHashSet();
 
        var failureMessage = new StringBuilder();
        failureMessage.AppendLine($"The following Predefined{providerType.Name}Names are not used as Name metadata:");
        var passLength = failureMessage.Length;
 
        var unusedPredefinedNames = predefinedNames.Except(providerNames);
        foreach (var name in unusedPredefinedNames)
        {
            failureMessage.AppendLine(name);
        }
 
        Assert.True(failureMessage.Length == passLength, failureMessage.ToString());
    }
 
    private static bool TryGetExportName(ExportDefinition export, [NotNullWhen(returnValue: true)] out string? name)
    {
        if (!export.Metadata.TryGetValue("Name", out var nameObj)
            || nameObj is not string { Length: > 0 })
        {
            name = null;
            return false;
        }
 
        name = (string)nameObj;
        return true;
    }
 
    private static ImmutableHashSet<string> GetPredefinedNamesFromType(Type namesType)
    {
        return namesType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)
            .Where(field => field.FieldType == typeof(string))
            .Select(field => (string)field.GetValue(null))
            .ToImmutableHashSet();
    }
 
    private static IEnumerable<(ComposedPart Part, ExportDefinition Export)> FindComposedPartsWithExport(
        CompositionConfiguration configuration,
        string exportedTypeName)
    {
        foreach (var part in configuration.Parts)
        {
            var export = part.Definition.ExportedTypes
                .FirstOrDefault(exportedType => exportedTypeName.Equals(exportedType.ContractName));
 
            if (export != null)
            {
                yield return (part, export);
            }
        }
    }
 
    private static IEnumerable<(ComposedPart Part, ExportDefinition Export)> FindComposedPartsWithExportForLanguage(
        CompositionConfiguration configuration,
        string exportedTypeName,
        string language)
    {
        return FindComposedPartsWithExport(configuration, exportedTypeName)
            .Where(part => ((string[])part.Export.Metadata["Languages"]!).Contains(language));
    }
}