// 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.

#nullable disable

using System;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.CodeFixes.Suppression;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.Suppression
{
    public partial class CSharpSuppressionTests : AbstractSuppressionDiagnosticTest
    {
        #region "Fix selected occurrences tests"

        public abstract class CSharpFixMultipleSuppressionTests : CSharpSuppressionTests
        {
            protected override int CodeActionIndex => 0;

            internal override Tuple<DiagnosticAnalyzer, IConfigurationFixProvider> CreateDiagnosticProviderAndFixer(Workspace workspace)
            {
                return new Tuple<DiagnosticAnalyzer, IConfigurationFixProvider>(
                    new UserDiagnosticAnalyzer(), new CSharpSuppressionCodeFixProvider());
            }

            private class UserDiagnosticAnalyzer : DiagnosticAnalyzer
            {
                public static readonly DiagnosticDescriptor Decsciptor1 =
                    new DiagnosticDescriptor("InfoDiagnostic", "InfoDiagnostic Title", "InfoDiagnostic", "InfoDiagnostic", DiagnosticSeverity.Info, isEnabledByDefault: true);
                public static readonly DiagnosticDescriptor Decsciptor2 =
                    new DiagnosticDescriptor("InfoDiagnostic2", "InfoDiagnostic2 Title", "InfoDiagnostic2", "InfoDiagnostic2", DiagnosticSeverity.Info, isEnabledByDefault: true);

                public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Decsciptor1, Decsciptor2);

                public override void Initialize(AnalysisContext context)
                    => context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.ClassDeclaration);

                public void AnalyzeNode(SyntaxNodeAnalysisContext context)
                {
                    var classDecl = (ClassDeclarationSyntax)context.Node;
                    var location = classDecl.Identifier.GetLocation();
                    context.ReportDiagnostic(Diagnostic.Create(Decsciptor1, location));
                    context.ReportDiagnostic(Diagnostic.Create(Decsciptor2, location));
                }
            }

            #region "Pragma disable tests"

            public class CSharpFixMultiplePragmaWarningSuppressionTests : CSharpFixMultipleSuppressionTests
            {
                [Fact]
                [Trait(Traits.Feature, Traits.Features.CodeActionsSuppression)]
                [Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
                [WorkItem("https://github.com/dotnet/roslyn/issues/6455")]
                public async Task TestFixMultipleInDocument()
                {
                    var input = """
                        <Workspace>
                            <Project Language="C#" AssemblyName="Assembly1" CommonReferences="true">
                                <Document>
                        using System;

                        {|FixAllInSelection:class Class1
                        {
                            int Method()
                            {
                                int x = 0;
                            }
                        }

                        class Class2
                        {
                        }|}
                        class Class3 { }
                                </Document>
                                <Document>
                        class Class3
                        {
                        }
                                </Document>
                            </Project>
                            <Project Language="C#" AssemblyName="Assembly2" CommonReferences="true">
                                <Document>
                        class Class1
                        {
                            int Method()
                            {
                                int x = 0;
                            }
                        }

                        class Class2
                        {
                        }
                                </Document>
                            </Project>
                        </Workspace>
                        """;

                    var expected = """
                        <Workspace>
                            <Project Language="C#" AssemblyName="Assembly1" CommonReferences="true">
                                <Document>
                        using System;

                        #pragma warning disable InfoDiagnostic // InfoDiagnostic Title
                        #pragma warning disable InfoDiagnostic2 // InfoDiagnostic2 Title
                        class Class1
                        #pragma warning restore InfoDiagnostic2 // InfoDiagnostic2 Title
                        #pragma warning restore InfoDiagnostic // InfoDiagnostic Title
                        {
                            int Method()
                            {
                                int x = 0;
                            }
                        }

                        #pragma warning disable InfoDiagnostic // InfoDiagnostic Title
                        #pragma warning disable InfoDiagnostic2 // InfoDiagnostic2 Title
                        class Class2
                        #pragma warning restore InfoDiagnostic2 // InfoDiagnostic2 Title
                        #pragma warning restore InfoDiagnostic // InfoDiagnostic Title
                        {
                        }
                        class Class3 { }
                                </Document>
                                <Document>
                        class Class3
                        {
                        }
                                </Document>
                            </Project>
                            <Project Language="C#" AssemblyName="Assembly2" CommonReferences="true">
                                <Document>
                        class Class1
                        {
                            int Method()
                            {
                                int x = 0;
                            }
                        }

                        class Class2
                        {
                        }
                                </Document>
                            </Project>
                        </Workspace>
                        """;

                    await TestInRegularAndScriptAsync(input, expected);
                }
            }

            #endregion
        }

        #endregion
    }
}
