// 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.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CSharp.MakeTypePartial;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Microsoft.CodeAnalysis.Testing;
using Xunit;
 
namespace Microsoft.CodeAnalysis.CSharp.CSharp.UnitTests.MakeTypePartial;
 
using VerifyCS = CSharpCodeFixVerifier<
    EmptyDiagnosticAnalyzer,
    CSharpMakeTypePartialCodeFixProvider>;
 
[Trait(Traits.Feature, Traits.Features.CodeActionsMakeTypePartial)]
public sealed class MakeTypePartialTests
{
    public static IEnumerable<object[]> AllValidDeclarationTypes()
    {
        yield return new[] { "class" };
        yield return new[] { "struct" };
        yield return new[] { "interface" };
        yield return new[] { "record" };
        yield return new[] { "record class" };
        yield return new[] { "record struct" };
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task OutsideNamespace(string declarationType)
    {
        await new VerifyCS.Test
        {
            TestCode = $$"""
                partial {{declarationType}} Declaration
                {
                }
            
                {{declarationType}} {|CS0260:Declaration|}
                {
                }
                """,
            FixedCode = $$"""
                partial {{declarationType}} Declaration
                {
                }
            
                partial {{declarationType}} Declaration
                {
                }
                """,
            LanguageVersion = LanguageVersion.CSharp10
        }.RunAsync();
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task InsideOneFileScopedNamespace(string declarationType)
    {
        await new VerifyCS.Test
        {
            TestCode = $$"""
                namespace TestNamespace;
            
                partial {{declarationType}} Declaration
                {
                }
            
                {{declarationType}} {|CS0260:Declaration|}
                {
                }
                """,
            FixedCode = $$"""
                namespace TestNamespace;
            
                partial {{declarationType}} Declaration
                {
                }
            
                partial {{declarationType}} Declaration
                {
                }
                """,
            LanguageVersion = LanguageVersion.CSharp10
        }.RunAsync();
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task InsideOneBlockScopedNamespace(string declarationType)
    {
        await new VerifyCS.Test
        {
            TestCode = $$"""
                namespace TestNamespace
                {
                    partial {{declarationType}} Declaration
                    {
                    }
            
                    {{declarationType}} {|CS0260:Declaration|}
                    {
                    }
                }
                """,
            FixedCode = $$"""
                namespace TestNamespace
                {
                    partial {{declarationType}} Declaration
                    {
                    }
            
                    partial {{declarationType}} Declaration
                    {
                    }
                }
                """,
            LanguageVersion = LanguageVersion.CSharp10
        }.RunAsync();
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task InsideTwoEqualBlockScopedNamespaces(string declarationType)
    {
        await new VerifyCS.Test
        {
            TestCode = $$"""
                namespace TestNamespace
                {
                    partial {{declarationType}} Declaration
                    {
                    }
                }
            
                namespace TestNamespace
                {
                    {{declarationType}} {|CS0260:Declaration|}
                    {
                    }
                }
                """,
            FixedCode = $$"""
                namespace TestNamespace
                {
                    partial {{declarationType}} Declaration
                    {
                    }
                }
            
                namespace TestNamespace
                {
                    partial {{declarationType}} Declaration
                    {
                    }
                }
                """,
            LanguageVersion = LanguageVersion.CSharp10
        }.RunAsync();
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task InDifferentDocuments(string declarationType)
    {
        var document1 = $$"""
            partial {{declarationType}} Declaration
            {
            }
            """;
 
        var document2 = $$"""
            {{declarationType}} {|CS0260:Declaration|}
            {
            }
            """;
 
        var fixedDocument2 = $$"""
            partial {{declarationType}} Declaration
            {
            }
            """;
 
        await new VerifyCS.Test
        {
            TestState =
            {
                Sources = { document1, document2 }
            },
            FixedState =
            {
                Sources = { document1, fixedDocument2 }
            },
            LanguageVersion = LanguageVersion.CSharp10
        }.RunAsync();
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task WithOtherModifiers(string declarationType)
    {
        await new VerifyCS.Test
        {
            TestCode = $$"""
                public partial {{declarationType}} Declaration
                {
                }
            
                public {{declarationType}} {|CS0260:Declaration|}
                {
                }
                """,
            FixedCode = $$"""
                public partial {{declarationType}} Declaration
                {
                }
            
                public partial {{declarationType}} Declaration
                {
                }
                """,
            LanguageVersion = LanguageVersion.CSharp10
        }.RunAsync();
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task NestedType1(string declarationType)
    {
        await new VerifyCS.Test
        {
            TestCode = $$"""
                class Test
                {
                    public partial {{declarationType}} Declaration
                    {
                    }
            
                    public {{declarationType}} {|CS0260:Declaration|}
                    {
                    }
                }
                """,
            FixedCode = $$"""
                class Test
                {
                    public partial {{declarationType}} Declaration
                    {
                    }
            
                    public partial {{declarationType}} Declaration
                    {
                    }
                }
                """,
            LanguageVersion = LanguageVersion.CSharp10
        }.RunAsync();
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task NestedType2(string declarationType)
    {
        await new VerifyCS.Test
        {
            TestCode = $$"""
                partial {{declarationType}} Test
                {
                }
 
                {{declarationType}} {|CS0260:Test|}
                {
                    public partial {{declarationType}} Declaration
                    {
                    }
            
                    public {{declarationType}} {|CS0260:Declaration|}
                    {
                    }
                }
                """,
            FixedCode = $$"""
                partial {{declarationType}} Test
                {
                }
 
                partial {{declarationType}} Test
                {
                    public partial {{declarationType}} Declaration
                    {
                    }
            
                    public partial {{declarationType}} Declaration
                    {
                    }
                }
                """,
            LanguageVersion = LanguageVersion.CSharp10
        }.RunAsync();
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task FixOne(string declarationType)
    {
        var testCode = $$"""
            partial {{declarationType}} Test
            {
            }
            
            {{declarationType}} {|CS0260:Test|}
            {
            }
            
            {{declarationType}} {|CS0260:Test|}
            {
            }
            """;
        var fixedCode = $$"""
            partial {{declarationType}} Test
            {
            }
            
            partial {{declarationType}} Test
            {
            }
            
            partial {{declarationType}} Test
            {
            }
            """;
 
        await new VerifyCS.Test
        {
            TestCode = testCode,
            FixedCode = fixedCode,
            LanguageVersion = LanguageVersion.CSharp10,
            CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne,
            DiagnosticSelector = d => d[0]
        }.RunAsync();
 
        await new VerifyCS.Test
        {
            TestCode = testCode,
            FixedCode = fixedCode,
            LanguageVersion = LanguageVersion.CSharp10,
            CodeFixTestBehaviors = CodeFixTestBehaviors.FixOne,
            DiagnosticSelector = d => d[1]
        }.RunAsync();
    }
 
    [Theory]
    [MemberData(nameof(AllValidDeclarationTypes))]
    public async Task NotInDifferentNamespaces(string declarationType)
    {
        var markup = $$"""
            namespace TestNamespace1
            {
                partial {{declarationType}} Declaration
                {
                }
            }
            
            namespace TestNamespace2
            {
                {{declarationType}} Declaration
                {
                }
            }
            """;
 
        await new VerifyCS.Test
        {
            TestCode = markup,
            LanguageVersion = LanguageVersion.CSharp10
        }.RunAsync();
    }
}