// 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.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.ArgumentProviders
{
    [UseExportProvider]
    public class ArgumentProviderOrderTests
    {
        /// <summary>
        /// Verifies the exact order of all built-in argument providers.
        /// </summary>
        [Fact]
        public void TestArgumentProviderOrder()
        {
            var exportProvider = EditorTestCompositions.EditorFeaturesWpf.ExportProviderFactory.CreateExportProvider();
            var argumentProviderExports = exportProvider.GetExports<ArgumentProvider, CompletionProviderMetadata>();
            var orderedCSharpArgumentProviders = ExtensionOrderer.Order(argumentProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp));
 
            var actualOrder = orderedCSharpArgumentProviders.Select(x => x.Value.GetType()).ToArray();
            var expectedOrder = new[]
            {
                // Marker for start of built-in argument providers
                typeof(FirstBuiltInArgumentProvider),
 
                // Built-in providers
                typeof(ContextVariableArgumentProvider),
                typeof(OutVariableArgumentProvider),
                typeof(DefaultArgumentProvider),
 
                // Marker for end of built-in argument providers
                typeof(LastBuiltInArgumentProvider),
            };
 
            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 argument 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 argument, the provider that provides the winning one is consistent.</remarks>
        [Fact]
        public void TestArgumentProviderOrderMetadata()
        {
            var exportProvider = EditorTestCompositions.EditorFeatures.ExportProviderFactory.CreateExportProvider();
            var argumentProviderExports = exportProvider.GetExports<ArgumentProvider, CompletionProviderMetadata>();
            var orderedCSharpArgumentProviders = ExtensionOrderer.Order(argumentProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp));
 
            for (var i = 0; i < orderedCSharpArgumentProviders.Count; i++)
            {
                if (i == 0)
                {
                    Assert.Empty(orderedCSharpArgumentProviders[i].Metadata.BeforeTyped);
                    Assert.Empty(orderedCSharpArgumentProviders[i].Metadata.AfterTyped);
                }
                else if (i == orderedCSharpArgumentProviders.Count - 1) // last one
                {
                    // The last one isn't before anything else
                    Assert.Empty(orderedCSharpArgumentProviders[i].Metadata.BeforeTyped);
 
                    // The last argument marker should be last; this is ensured by either the last "real" provider saying it comes before the
                    // marker, or the last argument marker comes after the last "real" provider.
                    if (!orderedCSharpArgumentProviders[i].Metadata.AfterTyped.Contains(orderedCSharpArgumentProviders[i - 1].Metadata.Name))
                    {
                        // Make sure the last built-in provider comes before the marker
                        Assert.Contains(orderedCSharpArgumentProviders[i].Metadata.Name, orderedCSharpArgumentProviders[i - 1].Metadata.BeforeTyped);
                    }
                }
                else
                {
                    if (orderedCSharpArgumentProviders[i].Metadata.BeforeTyped.Any())
                    {
                        Assert.Equal(orderedCSharpArgumentProviders.Last().Metadata.Name, Assert.Single(orderedCSharpArgumentProviders[i].Metadata.BeforeTyped));
                    }
 
                    var after = Assert.Single(orderedCSharpArgumentProviders[i].Metadata.AfterTyped);
                    Assert.Equal(orderedCSharpArgumentProviders[i - 1].Metadata.Name, after);
                }
            }
        }
 
        [Fact]
        public void TestArgumentProviderFirstNameMetadata()
        {
            var exportProvider = EditorTestCompositions.EditorFeatures.ExportProviderFactory.CreateExportProvider();
            var argumentProviderExports = exportProvider.GetExports<ArgumentProvider, CompletionProviderMetadata>();
            var orderedCSharpArgumentProviders = ExtensionOrderer.Order(argumentProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp));
            var firstArgumentProvider = orderedCSharpArgumentProviders.First();
 
            Assert.Equal("FirstBuiltInArgumentProvider", firstArgumentProvider.Metadata.Name);
        }
 
        [Fact]
        public void TestArgumentProviderLastNameMetadata()
        {
            var exportProvider = EditorTestCompositions.EditorFeatures.ExportProviderFactory.CreateExportProvider();
            var argumentProviderExports = exportProvider.GetExports<ArgumentProvider, CompletionProviderMetadata>();
            var orderedCSharpArgumentProviders = ExtensionOrderer.Order(argumentProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp));
            var lastArgumentProvider = orderedCSharpArgumentProviders.Last();
 
            Assert.Equal("LastBuiltInArgumentProvider", lastArgumentProvider.Metadata.Name);
        }
 
        [Fact]
        public void TestArgumentProviderNameMetadata()
        {
            var exportProvider = EditorTestCompositions.EditorFeatures.ExportProviderFactory.CreateExportProvider();
            var argumentProviderExports = exportProvider.GetExports<ArgumentProvider, CompletionProviderMetadata>();
            var csharpArgumentProviders = argumentProviderExports.Where(export => export.Metadata.Language == LanguageNames.CSharp);
            foreach (var export in csharpArgumentProviders)
            {
                Assert.Equal(export.Value.GetType().Name, export.Metadata.Name);
            }
        }
    }
}