// 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.Threading.Tasks;
using Microsoft.CodeAnalysis.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Recommendations
{
    [Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
    public class NamespaceKeywordRecommenderTests : KeywordRecommenderTests
    {
        [Fact]
        public async Task TestNotInUsingAlias()
        {
            await VerifyAbsenceAsync(
@"using Goo = $$");
        }
 
        [Fact]
        public async Task TestNotInGlobalUsingAlias()
        {
            await VerifyAbsenceAsync(
@"global using Goo = $$");
        }
 
        [Fact]
        public async Task TestNotAfterClass_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"class C { }
$$");
        }
 
        [Fact]
        public async Task TestNotAfterGlobalStatement_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"System.Console.WriteLine();
$$");
        }
 
        [Fact]
        public async Task TestNotAfterGlobalVariableDeclaration_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"int i = 0;
$$");
        }
 
        [Fact]
        public async Task TestNotInEmptyStatement()
        {
            await VerifyAbsenceAsync(AddInsideMethod(
@"$$"));
        }
 
        [Fact]
        public async Task TestAtRoot()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"$$");
        }
 
        [Fact]
        public async Task TestAtRoot_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"$$");
        }
 
        [Fact]
        public async Task TestNotAfterNamespaceKeyword()
            => await VerifyAbsenceAsync(@"namespace $$");
 
        [Fact]
        public async Task TestAfterPreviousNamespace()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"namespace N {}
$$");
        }
 
        [Fact]
        public async Task TestNotAfterPreviousFileScopedNamespace()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Regular,
@"namespace N;
$$");
        }
 
        [Fact]
        public async Task TestNotAfterUsingInFileScopedNamespace()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Regular,
@"namespace N;
using U;
$$");
        }
 
        [Fact]
        public async Task TestAfterUsingInNamespace()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"namespace N
{
    using U;
    $$
}");
        }
 
        [Fact]
        public async Task TestAfterPreviousNamespace_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"namespace N {}
$$");
        }
 
        [Fact]
        public async Task TestAfterExtern()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"extern alias goo;
$$");
        }
 
        [Fact]
        public async Task TestAfterExtern_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"extern alias goo;
$$");
        }
 
        [Fact]
        public async Task TestNotAfterExternInFileScopedNamespace()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Regular,
@"namespace N;
extern alias A;
$$");
        }
 
        [Fact]
        public async Task TestAfterExternInNamespace()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"namespace N
{
    extern alias A;
    $$
}");
        }
 
        [Fact]
        public async Task TestAfterUsing()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"using Goo;
$$");
        }
 
        [Fact]
        public async Task TestAfterGlobalUsing()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"global using Goo;
$$");
        }
 
        [Fact]
        public async Task TestAfterUsing_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"using Goo;
$$");
        }
 
        [Fact]
        public async Task TestAfterGlobalUsing_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"global using Goo;
$$");
        }
 
        [Fact]
        public async Task TestAfterUsingAlias()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"using Goo = Bar;
$$");
        }
 
        [Fact]
        public async Task TestAfterUsingAlias_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"using Goo = Bar;
$$");
        }
 
        [Fact]
        public async Task TestAfterGlobalUsingAlias()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"global using Goo = Bar;
$$");
        }
 
        [Fact]
        public async Task TestAfterGlobalUsingAlias_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"global using Goo = Bar;
$$");
        }
 
        [Fact]
        public async Task TestAfterClassDeclaration()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"class C {}
$$");
        }
 
        [Fact]
        public async Task TestAfterClassDeclaration_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"class C {}
$$");
        }
 
        [Fact]
        public async Task TestAfterDelegateDeclaration()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"delegate void D();
$$");
        }
 
        [Fact]
        public async Task TestAfterDelegateDeclaration_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"delegate void D();
$$");
        }
 
        [Fact]
        public async Task TestNotAfterNestedDelegateDeclaration()
        {
            await VerifyAbsenceAsync(
@"class C {
    delegate void D();
    $$");
        }
 
        [Fact]
        public async Task TestNotAfterNestedMember()
        {
            await VerifyAbsenceAsync(@"class A {
    class C {}
    $$");
        }
 
        [Fact]
        public async Task TestInsideNamespace()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"namespace N {
    $$");
        }
 
        [Fact]
        public async Task TestInsideNamespace_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"namespace N {
    $$");
        }
 
        [Fact]
        public async Task TestNotAfterNamespaceKeyword_InsideNamespace()
        {
            await VerifyAbsenceAsync(@"namespace N {
    namespace $$");
        }
 
        [Fact]
        public async Task TestAfterPreviousNamespace_InsideNamespace()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"namespace N {
   namespace N1 {}
   $$");
        }
 
        [Fact]
        public async Task TestAfterPreviousNamespace_InsideNamespace_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"namespace N {
   namespace N1 {}
   $$");
        }
 
        [Fact]
        public async Task TestNotBeforeUsing_InsideNamespace()
        {
            await VerifyAbsenceAsync(@"namespace N {
    $$
    using Goo;");
        }
 
        [Fact]
        public async Task TestAfterMember_InsideNamespace()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"namespace N {
    class C {}
    $$");
        }
 
        [Fact]
        public async Task TestAfterMember_InsideNamespace_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"namespace N {
    class C {}
    $$");
        }
 
        [Fact]
        public async Task TestNotAfterNestedMember_InsideNamespace()
        {
            await VerifyAbsenceAsync(@"namespace N {
    class A {
      class C {}
      $$");
        }
 
        [Fact]
        public async Task TestNotBeforeExtern()
        {
            await VerifyAbsenceAsync(@"$$
extern alias Goo;");
        }
 
        [Fact]
        public async Task TestNotBeforeUsing()
        {
            await VerifyAbsenceAsync(@"$$
using Goo;");
        }
 
        [Fact]
        public async Task TestNotBeforeGlobalUsing()
        {
            await VerifyAbsenceAsync(@"$$
global using Goo;");
        }
 
        [Fact]
        public async Task TestNotBetweenUsings()
        {
            await VerifyAbsenceAsync(
@"using Goo;
$$
using Bar;");
        }
 
        [Fact]
        public async Task TestNotBetweenGlobalUsings_01()
        {
            await VerifyAbsenceAsync(
@"global using Goo;
$$
using Bar;");
        }
 
        [Fact]
        public async Task TestNotBetweenGlobalUsings_02()
        {
            await VerifyAbsenceAsync(
@"global using Goo;
$$
global using Bar;");
        }
 
        [Fact]
        public async Task TestAfterGlobalAttribute()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
@"[assembly: Goo]
$$");
        }
 
        [Fact]
        public async Task TestAfterGlobalAttribute_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
@"[assembly: Goo]
$$");
        }
 
        [Fact]
        public async Task TestNotAfterAttribute()
        {
            await VerifyAbsenceAsync(
@"[Goo]
$$");
        }
 
        [Fact]
        public async Task TestNotAfterNestedAttribute()
        {
            await VerifyAbsenceAsync(
@"class C {
  [Goo]
  $$");
        }
 
        [Fact]
        public async Task TestAfterRegion()
        {
            await VerifyKeywordAsync(SourceCodeKind.Regular,
        @"#region EDM Relationship Metadata
 
[assembly: EdmRelationshipAttribute(""PerformanceResultsModel"", ""FK_Runs_Machines"", ""Machines"", System.Data.Metadata.Edm.RelationshipMultiplicity.One, typeof(PerformanceViewerSL.Web.Machine), ""Runs"", System.Data.Metadata.Edm.RelationshipMultiplicity.Many, typeof(PerformanceViewerSL.Web.Run), true)]
 
#endregion
 
$$");
        }
 
        [Fact]
        public async Task TestAfterRegion_Interactive()
        {
            await VerifyAbsenceAsync(SourceCodeKind.Script,
        @"#region EDM Relationship Metadata
 
[assembly: EdmRelationshipAttribute(""PerformanceResultsModel"", ""FK_Runs_Machines"", ""Machines"", System.Data.Metadata.Edm.RelationshipMultiplicity.One, typeof(PerformanceViewerSL.Web.Machine), ""Runs"", System.Data.Metadata.Edm.RelationshipMultiplicity.Many, typeof(PerformanceViewerSL.Web.Run), true)]
 
#endregion
 
$$");
        }
    }
}