// 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.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.RemoveUnnecessarySuppressions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeFixVerifier<
    Microsoft.CodeAnalysis.CSharp.RemoveUnnecessarySuppressions.CSharpRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer,
    Microsoft.CodeAnalysis.RemoveUnnecessarySuppressions.RemoveUnnecessaryAttributeSuppressionsCodeFixProvider>;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.RemoveUnnecessarySuppressions
{
    [Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessarySuppressions)]
    [WorkItem("https://github.com/dotnet/roslyn/issues/44176")]
    public class RemoveUnnecessaryAttributeSuppressionsTests
    {
        [Theory, CombinatorialData]
        public void TestStandardProperty(AnalyzerProperty property)
            => VerifyCS.VerifyStandardProperty(property);
 
        [Theory]
        // Field
        [InlineData(@"Scope = ""member""", @"Target = ""~F:N.C.F""", "assembly")]
        // Property
        [InlineData(@"Scope = ""member""", @"Target = ""~P:N.C.P""", "assembly")]
        // Method
        [InlineData(@"Scope = ""member""", @"Target = ""~M:N.C.M()""", "assembly")]
        // Type
        [InlineData(@"Scope = ""member""", @"Target = ""~T:N.C""", "assembly")]
        // Namespace
        [InlineData(@"Scope = ""namespace""", @"Target = ""~N:N""", "assembly")]
        // NamespaceAndDescendants
        [InlineData(@"Scope = ""namespaceanddescendants""", @"Target = ""~N:N""", "assembly")]
        // Module - no scope, no target
        [InlineData(null, null, "assembly")]
        // Module - no target
        [InlineData(@"Scope = ""module""", null, "assembly")]
        // Module - null target
        [InlineData(@"Scope = ""module""", @"Target = null", "assembly")]
        // Resource - not handled
        [InlineData(@"Scope = ""resource""", @"Target = """"", "assembly")]
        // 'module' attribute target
        [InlineData(@"Scope = ""member""", @"Target = ""~M:N.C.M()""", "module")]
        // Member with non-matching scope (seems to be respected by suppression decoder)
        [InlineData(@"Scope = ""type""", @"Target = ""~M:N.C.M()""", "assembly")]
        [InlineData(@"Scope = ""namespace""", @"Target = ""~F:N.C.F""", "assembly")]
        // Case insensitive scope
        [InlineData(@"Scope = ""Member""", @"Target = ""~F:N.C.F""", "assembly")]
        [InlineData(@"Scope = ""MEMBER""", @"Target = ""~F:N.C.F""", "assembly")]
        public async Task ValidSuppressions(string? scope, string? target, string attributeTarget)
        {
            var scopeString = scope != null ? $@", {scope}" : string.Empty;
            var targetString = target != null ? $@", {target}" : string.Empty;
 
            var input = $@"
[{attributeTarget}: System.Diagnostics.CodeAnalysis.SuppressMessage(""Category"", ""Id: Title"", Justification = ""Pending""{scopeString}{targetString})]
 
namespace N
{{
    class C
    {{
        public int F;
        public int P {{ get; }}
        public void M() {{ }}
    }}
}}";
            await VerifyCS.VerifyCodeFixAsync(input, input);
        }
 
        [Theory]
        // Field - no matching symbol
        [InlineData(@"Scope = ""member""", @"Target = ""~F:N.C.F2""", "assembly")]
        // Field - no matching symbol (case insensitive)
        [InlineData(@"Scope = ""Member""", @"Target = ""~F:N.C.F2""", "assembly")]
        [InlineData(@"Scope = ""MEMBER""", @"Target = ""~F:N.C.F2""", "assembly")]
        // Property - invalid scope
        [InlineData(@"Scope = ""invalid""", @"Target = ""~P:N.C.P""", "assembly")]
        // Method - wrong signature
        [InlineData(@"Scope = ""member""", @"Target = ""~M:N.C.M(System.Int32)""", "assembly")]
        // Method - module scope
        [InlineData(@"Scope = ""module""", @"Target = ""~M:N.C.M()""", "assembly")]
        // Method - null scope
        [InlineData(@"Scope = null", @"Target = ""~M:N.C.M()""", "assembly")]
        // Method - no scope
        [InlineData(null, @"Target = ""~M:N.C.M()""", "assembly")]
        // Member scope - null target
        [InlineData(@"Scope = ""member""", @"Target = null", "assembly")]
        // Member scope - no target
        [InlineData(@"Scope = ""member""", null, "assembly")]
        // Type - no matching namespace
        [InlineData(@"Scope = ""type""", @"Target = ""~T:N2.C""", "assembly")]
        // Namespace - extra namespace qualification
        [InlineData(@"Scope = ""namespace""", @"Target = ""~N:N.N2""", "assembly")]
        // NamespaceAndDescendants - empty target
        [InlineData(@"Scope = ""namespaceanddescendants""", @"Target = """"", "assembly")]
        // Module - no scope, empty target
        [InlineData(null, @"Target = """"", "assembly")]
        // Module - no scope, non-empty target
        [InlineData(null, @"Target = ""~T:N.C""", "assembly")]
        // Module scope, empty target
        [InlineData(@"Scope = ""module""", @"Target = """"", "assembly")]
        // Module no scope, non-empty target
        [InlineData(@"Scope = ""module""", @"Target = ""~T:N.C""", "assembly")]
        public async Task InvalidSuppressions(string? scope, string? target, string attributeTarget)
        {
            var scopeString = scope != null ? $@", {scope}" : string.Empty;
            var targetString = target != null ? $@", {target}" : string.Empty;
 
            var input = $@"
[{attributeTarget}: [|System.Diagnostics.CodeAnalysis.SuppressMessage(""Category"", ""Id: Title"", Justification = ""Pending""{scopeString}{targetString})|]]
 
namespace N
{{
    class C
    {{
        public int F;
        public int P {{ get; }}
        public void M() {{ }}
    }}
}}";
 
            var fixedCode = $@"
 
namespace N
{{
    class C
    {{
        public int F;
        public int P {{ get; }}
        public void M() {{ }}
    }}
}}";
            await VerifyCS.VerifyCodeFixAsync(input, fixedCode);
        }
 
        [Fact]
        public async Task ValidAndInvalidSuppressions()
        {
            var attributePrefix = @"System.Diagnostics.CodeAnalysis.SuppressMessage(""Category"", ""Id: Title"", Justification = ""Pending""";
            var validSuppression = $@"{attributePrefix}, Scope = ""member"", Target = ""~T:C"")";
            var invalidSuppression = $@"[|{attributePrefix}, Scope = ""member"", Target = """")|]";
 
            var input = $@"
[assembly: {validSuppression}]
[assembly: {invalidSuppression}]
[assembly: {validSuppression}, {validSuppression}]
[assembly: {invalidSuppression}, {invalidSuppression}]
[assembly: {validSuppression}, {invalidSuppression}]
[assembly: {invalidSuppression}, {validSuppression}]
[assembly: {invalidSuppression}, {validSuppression}, {invalidSuppression}, {validSuppression}]
 
class C {{ }}
";
 
            var fixedCode = $@"
[assembly: {validSuppression}]
[assembly: {validSuppression}, {validSuppression}]
[assembly: {validSuppression}]
[assembly: {validSuppression}]
[assembly: {validSuppression}, {validSuppression}]
 
class C {{ }}
";
            await VerifyCS.VerifyCodeFixAsync(input, fixedCode);
        }
 
        [Theory]
        [InlineData("")]
        [InlineData(@", Scope = ""member"", Target = ""~M:C.M()""")]
        [InlineData(@", Scope = ""invalid"", Target = ""invalid""")]
        public async Task LocalSuppressions(string scopeAndTarget)
        {
            var input = $@"
[System.Diagnostics.CodeAnalysis.SuppressMessage(""Category"", ""Id: Title"", Justification = ""Pending""{scopeAndTarget})]
class C
{{
    public void M() {{ }}
}}";
            await VerifyCS.VerifyCodeFixAsync(input, input);
        }
 
        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/45465")]
        public async Task LegacyModeGlobalSuppressionWithNamespaceAndDescendantsScope()
        {
            var target = "N:N.InvalidChild";
            var input = $@"
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage(""Category"", ""Id: Title"", Scope = ""namespaceanddescendants"", Target = {{|#0:""{target}""|}})]
 
namespace N
{{
    class C {{ }}
}}";
            var expectedDiagnostic = VerifyCS.Diagnostic(AbstractRemoveUnnecessaryAttributeSuppressionsDiagnosticAnalyzer.LegacyFormatTargetDescriptor)
                                        .WithLocation(0)
                                        .WithArguments(target);
 
            await VerifyCS.VerifyCodeFixAsync(input, expectedDiagnostic, input);
        }
    }
}