// 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;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Composition;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.Host.Mef;
using Microsoft.CodeAnalysis.Text;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Formatting;
 
public partial class CodeCleanupTests
{
    private abstract class TestThirdPartyCodeFix : CodeFixProvider
    {
        public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create("HasDefaultCase");
 
        public override Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            foreach (var diagnostic in context.Diagnostics)
            {
                context.RegisterCodeFix(
                    CodeAction.Create(
                        "Remove default case",
                        async cancellationToken =>
                        {
                            var root = await context.Document.GetSyntaxRootAsync(cancellationToken);
                            Assumes.NotNull(root);
                            var sourceTree = diagnostic.Location.SourceTree;
                            Assumes.NotNull(sourceTree);
                            var node = (await sourceTree.GetRootAsync(cancellationToken)).FindNode(diagnostic.Location.SourceSpan);
                            Assumes.NotNull(node?.Parent);
                            var newRoot = root.RemoveNode(node.Parent, SyntaxRemoveOptions.KeepNoTrivia);
                            Assumes.NotNull(newRoot);
                            return context.Document.WithSyntaxRoot(newRoot);
                        },
                        nameof(TestThirdPartyCodeFix)),
                    diagnostic);
            }
 
            return Task.CompletedTask;
        }
    }
 
    [PartNotDiscoverable, Shared, ExportCodeFixProvider(LanguageNames.CSharp)]
    private class TestThirdPartyCodeFixWithFixAll : TestThirdPartyCodeFix
    {
        [ImportingConstructor]
        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
        public TestThirdPartyCodeFixWithFixAll()
        {
        }
 
        public override FixAllProvider GetFixAllProvider() => BatchFixAllProvider.Instance;
    }
 
    [PartNotDiscoverable, Shared, ExportCodeFixProvider(LanguageNames.CSharp)]
    private class TestThirdPartyCodeFixWithOutFixAll : TestThirdPartyCodeFix
    {
        [ImportingConstructor]
        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
        public TestThirdPartyCodeFixWithOutFixAll()
        {
        }
    }
 
    [PartNotDiscoverable, Shared, ExportCodeFixProvider(LanguageNames.CSharp)]
    private class TestThirdPartyCodeFixModifiesSolution : TestThirdPartyCodeFix
    {
        [ImportingConstructor]
        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
        public TestThirdPartyCodeFixModifiesSolution()
        {
        }
 
        public override FixAllProvider GetFixAllProvider() => new ModifySolutionFixAll();
 
        private class ModifySolutionFixAll : FixAllProvider
        {
            public override Task<CodeAction?> GetFixAsync(FixAllContext fixAllContext)
            {
                var solution = fixAllContext.Solution;
                return Task.FromResult<CodeAction?>(CodeAction.Create(
                        "Remove default case",
                        async cancellationToken =>
                        {
                            var toFix = await fixAllContext.GetDocumentDiagnosticsToFixAsync();
                            Project? project = null;
                            foreach (var kvp in toFix)
                            {
                                var document = kvp.Key;
                                project ??= document.Project;
                                var diagnostics = kvp.Value;
                                var root = await document.GetSyntaxRootAsync(cancellationToken);
                                Assumes.NotNull(root);
                                foreach (var diagnostic in diagnostics)
                                {
                                    var sourceTree = diagnostic.Location.SourceTree;
                                    Assumes.NotNull(sourceTree);
                                    var node = (await sourceTree.GetRootAsync(cancellationToken)).FindNode(diagnostic.Location.SourceSpan);
                                    Assumes.NotNull(node?.Parent);
                                    var newRoot = root.RemoveNode(node.Parent, SyntaxRemoveOptions.KeepNoTrivia);
                                    Assumes.NotNull(newRoot);
                                    document = document.WithSyntaxRoot(newRoot);
                                }
 
                                solution = solution.WithDocumentText(document.Id, await document.GetTextAsync());
                            }
 
                            Assumes.NotNull(project);
                            return solution.AddDocument(DocumentId.CreateNewId(project.Id), "new.cs", SourceText.From(""));
                        },
                        nameof(TestThirdPartyCodeFix)));
            }
        }
    }
 
    [PartNotDiscoverable, Shared, ExportCodeFixProvider(LanguageNames.CSharp)]
    private class TestThirdPartyCodeFixDoesNotSupportDocumentScope : TestThirdPartyCodeFix
    {
        [ImportingConstructor]
        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
        public TestThirdPartyCodeFixDoesNotSupportDocumentScope()
        {
        }
 
        public override FixAllProvider GetFixAllProvider() => new ModifySolutionFixAll();
 
        private class ModifySolutionFixAll : FixAllProvider
        {
            public override IEnumerable<FixAllScope> GetSupportedFixAllScopes()
            {
                return new[] { FixAllScope.Project, FixAllScope.Solution, FixAllScope.Custom };
            }
 
            public override Task<CodeAction?> GetFixAsync(FixAllContext fixAllContext)
            {
                var solution = fixAllContext.Solution;
                return Task.FromResult<CodeAction?>(CodeAction.Create(
                        "Remove default case",
                        async cancellationToken =>
                        {
                            var toFix = await fixAllContext.GetDocumentDiagnosticsToFixAsync();
                            Project? project = null;
                            foreach (var kvp in toFix)
                            {
                                var document = kvp.Key;
                                project ??= document.Project;
                                var diagnostics = kvp.Value;
                                var root = await document.GetSyntaxRootAsync(cancellationToken);
                                Assumes.NotNull(root);
                                foreach (var diagnostic in diagnostics)
                                {
                                    var sourceTree = diagnostic.Location.SourceTree;
                                    Assumes.NotNull(sourceTree);
                                    var node = (await sourceTree.GetRootAsync(cancellationToken)).FindNode(diagnostic.Location.SourceSpan);
                                    Assumes.NotNull(node?.Parent);
                                    var newRoot = root.RemoveNode(node.Parent, SyntaxRemoveOptions.KeepNoTrivia);
                                    Assumes.NotNull(newRoot);
                                    document = document.WithSyntaxRoot(newRoot);
                                }
 
                                solution = solution.WithDocumentText(document.Id, await document.GetTextAsync());
                            }
 
                            Assumes.NotNull(project);
                            return solution.AddDocument(DocumentId.CreateNewId(project.Id), "new.cs", SourceText.From(""));
                        },
                        nameof(TestThirdPartyCodeFix)));
            }
        }
    }
}