// 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.Linq;
using Microsoft.CodeAnalysis.Completion;
using Microsoft.CodeAnalysis.Completion.Providers;
using Microsoft.CodeAnalysis.CSharp.Completion.CompletionProviders.Snippets;
using Microsoft.CodeAnalysis.CSharp.Completion.Providers;
using Microsoft.CodeAnalysis.Editor.UnitTests;
using Microsoft.CodeAnalysis.Shared.Utilities;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Completion.CompletionProviders
{
    [UseExportProvider]
    public class CompletionProviderOrderTests
    {
        /// <summary>
        /// Verifies the exact order of all built-in completion providers.
        /// </summary>
        [Fact]
        public void TestCompletionProviderOrder()
        {
            var exportProvider = EditorTestCompositions.EditorFeaturesWpf.ExportProviderFactory.CreateExportProvider();
            var completionProviderExports = exportProvider.GetExports<CompletionProvider, CompletionProviderMetadata>();
            var orderedCSharpCompletionProviders = ExtensionOrderer.Order(completionProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp));
 
            var actualOrder = orderedCSharpCompletionProviders.Select(x => x.Value.GetType()).ToArray();
            var expectedOrder = new[]
            {
                // Marker for start of built-in completion providers
                typeof(FirstBuiltInCompletionProvider),
 
                // Built-in providers
                typeof(AttributeNamedParameterCompletionProvider),
                typeof(NamedParameterCompletionProvider),
                typeof(KeywordCompletionProvider),
                typeof(AwaitCompletionProvider),
                typeof(SpeculativeTCompletionProvider),
                typeof(SymbolCompletionProvider),
                typeof(UnnamedSymbolCompletionProvider),
                typeof(ExplicitInterfaceMemberCompletionProvider),
                typeof(ExplicitInterfaceTypeCompletionProvider),
                typeof(ObjectCreationCompletionProvider),
                typeof(ObjectAndWithInitializerCompletionProvider),
                typeof(CSharpSuggestionModeCompletionProvider),
                typeof(EnumAndCompletionListTagCompletionProvider),
                typeof(CrefCompletionProvider),
                typeof(SnippetCompletionProvider),
                typeof(ExternAliasCompletionProvider),
                typeof(PreprocessorCompletionProvider),
                typeof(OverrideCompletionProvider),
                typeof(PartialMethodCompletionProvider),
                typeof(PartialTypeCompletionProvider),
                typeof(XmlDocCommentCompletionProvider),
                typeof(TupleNameCompletionProvider),
                typeof(DeclarationNameCompletionProvider),
                typeof(InternalsVisibleToCompletionProvider),
                typeof(PropertySubpatternCompletionProvider),
                typeof(TypeImportCompletionProvider),
                typeof(ExtensionMethodImportCompletionProvider),
                typeof(AggregateEmbeddedLanguageCompletionProvider),
                typeof(FunctionPointerUnmanagedCallingConventionCompletionProvider),
                typeof(CSharpSnippetCompletionProvider),
 
                // Built-in interactive providers
                typeof(LoadDirectiveCompletionProvider),
                typeof(ReferenceDirectiveCompletionProvider),
 
                // Marker for end of built-in completion providers
                typeof(LastBuiltInCompletionProvider),
            };
 
            AssertEx.EqualOrDiff(
                string.Join(Environment.NewLine, expectedOrder.Select(x => x.FullName)),
                string.Join(Environment.NewLine, actualOrder.Select(x => x.FullName)));
        }
 
        /// <summary>
        /// Verifies that the order of built-in completion providers is deterministic.
        /// </summary>
        /// <remarks>We ensure that the order is deterministic by the list being explicit: each provider except the first must have
        /// a Before or After attribute that explicitly orders it by the next one in the list. This ensures that if more than
        /// one provider provides the same completion item, the provider that provides the winning one is consistent.</remarks>
        [Fact]
        public void TestCompletionProviderOrderMetadata()
        {
            var exportProvider = EditorTestCompositions.EditorFeatures.ExportProviderFactory.CreateExportProvider();
            var completionProviderExports = exportProvider.GetExports<CompletionProvider, CompletionProviderMetadata>();
            var orderedCSharpCompletionProviders = ExtensionOrderer.Order(completionProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp));
 
            for (var i = 0; i < orderedCSharpCompletionProviders.Count; i++)
            {
                if (i == 0)
                {
                    Assert.Empty(orderedCSharpCompletionProviders[i].Metadata.BeforeTyped);
                    Assert.Empty(orderedCSharpCompletionProviders[i].Metadata.AfterTyped);
                }
                else if (i == orderedCSharpCompletionProviders.Count - 1) // last one
                {
                    // The last one isn't before anything else
                    Assert.Empty(orderedCSharpCompletionProviders[i].Metadata.BeforeTyped);
 
                    // The last completion marker should be last; this is ensured by either the last "real" provider saying it comes before the
                    // marker, or the last completion marker comes after the last "real" provider.
                    if (!orderedCSharpCompletionProviders[i].Metadata.AfterTyped.Contains(orderedCSharpCompletionProviders[i - 1].Metadata.Name))
                    {
                        // Make sure the last built-in provider comes before the marker
                        Assert.Contains(orderedCSharpCompletionProviders[i].Metadata.Name, orderedCSharpCompletionProviders[i - 1].Metadata.BeforeTyped);
                    }
                }
                else
                {
                    if (orderedCSharpCompletionProviders[i].Metadata.BeforeTyped.Any())
                    {
                        Assert.Equal(orderedCSharpCompletionProviders.Last().Metadata.Name, Assert.Single(orderedCSharpCompletionProviders[i].Metadata.BeforeTyped));
                    }
 
                    var after = Assert.Single(orderedCSharpCompletionProviders[i].Metadata.AfterTyped);
                    Assert.Equal(orderedCSharpCompletionProviders[i - 1].Metadata.Name, after);
                }
            }
        }
 
        [Fact]
        public void TestCompletionProviderFirstNameMetadata()
        {
            var exportProvider = EditorTestCompositions.EditorFeatures.ExportProviderFactory.CreateExportProvider();
            var completionProviderExports = exportProvider.GetExports<CompletionProvider, CompletionProviderMetadata>();
            var orderedCSharpCompletionProviders = ExtensionOrderer.Order(completionProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp));
            var firstCompletionProvider = orderedCSharpCompletionProviders.First();
 
            Assert.Equal("FirstBuiltInCompletionProvider", firstCompletionProvider.Metadata.Name);
        }
 
        [Fact]
        public void TestCompletionProviderLastNameMetadata()
        {
            var exportProvider = EditorTestCompositions.EditorFeatures.ExportProviderFactory.CreateExportProvider();
            var completionProviderExports = exportProvider.GetExports<CompletionProvider, CompletionProviderMetadata>();
            var orderedCSharpCompletionProviders = ExtensionOrderer.Order(completionProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp));
            var lastCompletionProvider = orderedCSharpCompletionProviders.Last();
 
            Assert.Equal("LastBuiltInCompletionProvider", lastCompletionProvider.Metadata.Name);
        }
 
        [Fact]
        public void TestCompletionProviderNameMetadata()
        {
            var exportProvider = EditorTestCompositions.EditorFeatures.ExportProviderFactory.CreateExportProvider();
            var completionProviderExports = exportProvider.GetExports<CompletionProvider, CompletionProviderMetadata>();
            var csharpCompletionProviders = completionProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp);
            foreach (var export in csharpCompletionProviders)
            {
                Assert.Equal(export.Value.GetType().Name, export.Metadata.Name);
            }
        }
    }
}