// 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.CSharp.UnsealClass;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Microsoft.CodeAnalysis.Testing;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UnsealClass;
 
using VerifyCS = CSharpCodeFixVerifier<
    EmptyDiagnosticAnalyzer,
    CSharpUnsealClassCodeFixProvider>;
 
[Trait(Traits.Feature, Traits.Features.CodeActionsUnsealClass)]
public sealed class UnsealClassTests
{
    [Fact]
    public async Task RemovedFromSealedClass()
    {
        await VerifyCS.VerifyCodeFixAsync("""
            sealed class C
            {
            }
            class D : {|CS0509:C|}
            {
            }
            """, """
            class C
            {
            }
            class D : C
            {
            }
            """);
    }
 
    [Fact]
    public async Task RemovedFromSealedClassWithOtherModifiersPreserved()
    {
        await VerifyCS.VerifyCodeFixAsync("""
            public sealed unsafe class C
            {
            }
            class D : {|CS0509:C|}
            {
            }
            """, """
            public unsafe class C
            {
            }
            class D : C
            {
            }
            """);
    }
 
    [Fact]
    public async Task RemovedFromSealedClassWithConstructedGeneric()
    {
        await VerifyCS.VerifyCodeFixAsync("""
            sealed class C<T>
            {
            }
            class D : {|CS0509:C<int>|}
            {
            }
            """, """
            class C<T>
            {
            }
            class D : C<int>
            {
            }
            """);
    }
 
    [Fact]
    public async Task NotOfferedForNonSealedClass()
    {
        var code = """
            class C
            {
            }
            class D : C
            {
            }
            """;
 
        await VerifyCS.VerifyCodeFixAsync(code, code);
    }
 
    [Fact]
    public async Task NotOfferedForStaticClass()
    {
        var code = """
            static class C
            {
            }
            class {|CS0709:D|} : C
            {
            }
            """;
 
        await VerifyCS.VerifyCodeFixAsync(code, code);
    }
 
    [Fact]
    public async Task NotOfferedForStruct()
    {
        var code = """
            struct S
            {
            }
            class D : {|CS0509:S|}
            {
            }
            """;
 
        await VerifyCS.VerifyCodeFixAsync(code, code);
    }
 
    [Fact]
    public async Task NotOfferedForDelegate()
    {
        var code = """
            delegate void F();
 
            class D : {|CS0509:F|}
            {
            }
            """;
 
        await VerifyCS.VerifyCodeFixAsync(code, code);
    }
 
    [Fact]
    public async Task NotOfferedForSealedClassFromMetadata1()
    {
        var code = """
            class D : {|CS0509:string|}
            {
            }
            """;
 
        await VerifyCS.VerifyCodeFixAsync(code, code);
    }
 
    [Fact]
    public async Task NotOfferedForSealedClassFromMetadata2()
    {
        var code = """
            class D : {|CS0509:System.ApplicationId|}
            {
            }
            """;
 
        await VerifyCS.VerifyCodeFixAsync(code, code);
    }
 
    [Fact]
    public async Task RemovedFromAllPartialClassDeclarationsInSameFile()
    {
        await VerifyCS.VerifyCodeFixAsync("""
            public sealed partial class C
            {
            }
            partial class C
            {
            }
            sealed partial class C
            {
            }
            class D : {|CS0509:C|}
            {
            }
            """, """
            public partial class C
            {
            }
            partial class C
            {
            }
            partial class C
            {
            }
            class D : C
            {
            }
            """);
    }
 
    [Fact]
    public async Task RemovedFromAllPartialClassDeclarationsAcrossFiles()
    {
        var document1 = """
            public sealed partial class C
            {
            }
            """;
        var document2 = """
            partial class C
            {
            }
            sealed partial class C
            {
            }
            """;
        var document3 = """
            class D : {|CS0509:C|}
            {
            }
            """;
 
        var fixedDocument1 = """
            public partial class C
            {
            }
            """;
        var fixedDocument2 = """
            partial class C
            {
            }
            partial class C
            {
            }
            """;
        var fixedDocument3 = """
            class D : C
            {
            }
            """;
 
        await new VerifyCS.Test
        {
            TestState =
            {
                Sources = { document1, document2, document3 }
            },
            FixedState =
            {
                Sources = { fixedDocument1, fixedDocument2, fixedDocument3 }
            }
        }.RunAsync();
    }
 
    [Fact]
    public async Task RemovedFromClassInVisualBasicProject()
    {
        var csharpDocument = """
            class D : {|CS0509:C|}
            {
            }
            """;
        var vbDocument = """
            public notinheritable class C
            end class
            """;
 
        var fixedCSharpDocument = """
            class D : C
            {
            }
            """;
        var fixedVBDocument = """
            public class C
            end class
            """;
 
        await new VerifyCS.Test
        {
            TestState =
            {
                Sources = { csharpDocument },
                AdditionalProjectReferences = { "Project2" },
                AdditionalProjects =
                {
                    ["Project2", LanguageNames.VisualBasic] =
                    {
                        Sources = { vbDocument }
                    }
                }
            },
            FixedState =
            {
                Sources = { fixedCSharpDocument },
                AdditionalProjectReferences = { "Project2" },
                AdditionalProjects =
                {
                    ["Project2", LanguageNames.VisualBasic] =
                    {
                        Sources = { fixedVBDocument }
                    }
                }
            }
        }.RunAsync();
    }
}