// 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.Immutable;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.FindSymbols;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.UnsealClass
{
    internal abstract class AbstractUnsealClassCodeFixProvider : CodeFixProvider
    {
        protected abstract string TitleFormat { get; }

        public override FixAllProvider? GetFixAllProvider()
        {
            // This code fix addresses a very specific compiler error. It's unlikely there will be more than 1 of them at a time.
            return null;
        }

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var document = context.Document;
            var cancellationToken = context.CancellationToken;

            var syntaxRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            var node = syntaxRoot.FindNode(context.Span, getInnermostNodeForTie: true);

            if (semanticModel.GetSymbolInfo(node, cancellationToken).Symbol is INamedTypeSymbol type &&
                type.TypeKind == TypeKind.Class && type.IsSealed && !type.IsStatic)
            {
                var definition = await SymbolFinder.FindSourceDefinitionAsync(
                    type, document.Project.Solution, cancellationToken).ConfigureAwait(false);
                if (definition is not null && definition.DeclaringSyntaxReferences.Length > 0)
                {
                    var title = string.Format(TitleFormat, type.Name);
                    context.RegisterCodeFix(
                        CodeAction.Create(
                            title,
                            c => UnsealDeclarationsAsync(document.Project.Solution, definition.DeclaringSyntaxReferences, c),
                            title),
                        context.Diagnostics);
                }
            }
        }

        private static async Task<Solution> UnsealDeclarationsAsync(
            Solution solution, ImmutableArray<SyntaxReference> declarationReferences, CancellationToken cancellationToken)
        {
            foreach (var (documentId, syntaxReferences) in
                declarationReferences.GroupBy(reference => solution.GetDocumentId(reference.SyntaxTree)!))
            {
                var document = solution.GetRequiredDocument(documentId);
                var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);

                var editor = new SyntaxEditor(root, document.Project.Solution.Services);
                var generator = editor.Generator;

                foreach (var syntaxReference in syntaxReferences)
                {
                    var declaration = await syntaxReference.GetSyntaxAsync(cancellationToken).ConfigureAwait(false);

                    var modifiers = generator.GetModifiers(declaration);
                    if (modifiers.IsSealed)
                    {
                        var newDeclaration = generator.WithModifiers(declaration, modifiers.WithIsSealed(false));

                        editor.ReplaceNode(declaration, newDeclaration);
                    }
                }

                solution = solution.WithDocumentSyntaxRoot(documentId, editor.GetChangedRoot());
            }

            return solution;
        }
    }
}
