// 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.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeRefactorings;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Simplification;

namespace Microsoft.CodeAnalysis.AddDebuggerDisplay;

internal abstract class AbstractAddDebuggerDisplayCodeRefactoringProvider<
    TTypeDeclarationSyntax,
    TMethodDeclarationSyntax> : CodeRefactoringProvider
    where TTypeDeclarationSyntax : SyntaxNode
    where TMethodDeclarationSyntax : SyntaxNode
{
    private const string DebuggerDisplayPrefix = "{";
    private const string DebuggerDisplayMethodName = "GetDebuggerDisplay";
    private const string DebuggerDisplaySuffix = "(),nq}";

    protected abstract bool CanNameofAccessNonPublicMembersFromAttributeArgument { get; }

    protected abstract bool SupportsConstantInterpolatedStrings(Document document);

    public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
    {
        var (document, _, cancellationToken) = context;

        var typeAndPriority =
            await GetRelevantTypeFromHeaderAsync(context).ConfigureAwait(false) ??
            await GetRelevantTypeFromMethodAsync(context).ConfigureAwait(false);

        if (typeAndPriority == null)
            return;

        var (type, priority) = typeAndPriority.Value;

        var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
        var compilation = semanticModel.Compilation;

        var debuggerAttributeTypeSymbol = compilation.GetTypeByMetadataName("System.Diagnostics.DebuggerDisplayAttribute");
        if (debuggerAttributeTypeSymbol is null)
            return;

        var typeSymbol = (INamedTypeSymbol)semanticModel.GetRequiredDeclaredSymbol(type, cancellationToken);

        if (typeSymbol.IsStatic || !IsClassOrStruct(typeSymbol))
            return;

        if (HasDebuggerDisplayAttribute(typeSymbol, compilation))
            return;

        context.RegisterRefactoring(CodeAction.Create(
            FeaturesResources.Add_DebuggerDisplay_attribute,
            cancellationToken => ApplyAsync(document, type, debuggerAttributeTypeSymbol, cancellationToken),
            nameof(FeaturesResources.Add_DebuggerDisplay_attribute),
            priority));
    }

    private static async Task<(TTypeDeclarationSyntax type, CodeActionPriority priority)?> GetRelevantTypeFromHeaderAsync(CodeRefactoringContext context)
    {
        var type = await context.TryGetRelevantNodeAsync<TTypeDeclarationSyntax>().ConfigureAwait(false);
        if (type is null)
            return null;

        return (type, CodeActionPriority.Low);
    }

    private static async Task<(TTypeDeclarationSyntax type, CodeActionPriority priority)?> GetRelevantTypeFromMethodAsync(CodeRefactoringContext context)
    {
        var (document, _, cancellationToken) = context;
        var method = await context.TryGetRelevantNodeAsync<TMethodDeclarationSyntax>().ConfigureAwait(false);
        if (method == null)
            return null;

        var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
        var methodSymbol = (IMethodSymbol)semanticModel.GetRequiredDeclaredSymbol(method, cancellationToken);

        var isDebuggerDisplayMethod = IsDebuggerDisplayMethod(methodSymbol);
        if (!isDebuggerDisplayMethod && !IsToStringMethod(methodSymbol))
            return null;

        // Show the feature if we're on a ToString or GetDebuggerDisplay method. For the former,
        // have this be low-pri so we don't override more important light-bulb options.
        var typeDecl = method.FirstAncestorOrSelf<TTypeDeclarationSyntax>();
        if (typeDecl == null)
            return null;

        var priority = isDebuggerDisplayMethod ? CodeActionPriority.Default : CodeActionPriority.Low;
        return (typeDecl, priority);
    }

    private static bool IsToStringMethod(IMethodSymbol methodSymbol)
        => methodSymbol is { Name: nameof(ToString), Arity: 0, Parameters.IsEmpty: true };

    private static bool IsDebuggerDisplayMethod(IMethodSymbol methodSymbol)
        => methodSymbol is { Name: DebuggerDisplayMethodName, Arity: 0, Parameters.IsEmpty: true };

    private static bool IsClassOrStruct(ITypeSymbol typeSymbol)
        => typeSymbol.TypeKind is TypeKind.Class or TypeKind.Struct;

    private static bool HasDebuggerDisplayAttribute(ITypeSymbol typeSymbol, Compilation compilation)
        => typeSymbol.GetAttributes()
            .Select(data => data.AttributeClass)
            .Contains(compilation.GetTypeByMetadataName("System.Diagnostics.DebuggerDisplayAttribute"));

    private async Task<Document> ApplyAsync(Document document, TTypeDeclarationSyntax type, INamedTypeSymbol debuggerAttributeTypeSymbol, CancellationToken cancellationToken)
    {
        var syntaxRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
        var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);

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

        SyntaxNode attributeArgument;
        if (CanNameofAccessNonPublicMembersFromAttributeArgument)
        {
            if (SupportsConstantInterpolatedStrings(document))
            {
                attributeArgument = generator.InterpolatedStringExpression(
                    generator.CreateInterpolatedStringStartToken(isVerbatim: false),
                    [
                        generator.InterpolatedStringText(generator.InterpolatedStringTextToken("{{", "{{")),
                        generator.Interpolation(generator.NameOfExpression(generator.IdentifierName(DebuggerDisplayMethodName))),
                        generator.InterpolatedStringText(generator.InterpolatedStringTextToken("(),nq}}", "(),nq}}")),
                    ],
                    generator.CreateInterpolatedStringEndToken());
            }
            else
            {
                attributeArgument = generator.AddExpression(
                    generator.AddExpression(
                        generator.LiteralExpression(DebuggerDisplayPrefix),
                        generator.NameOfExpression(generator.IdentifierName(DebuggerDisplayMethodName))),
                    generator.LiteralExpression(DebuggerDisplaySuffix));
            }
        }
        else
        {
            attributeArgument = generator.LiteralExpression(
                DebuggerDisplayPrefix + DebuggerDisplayMethodName + DebuggerDisplaySuffix);
        }

        var newAttribute = generator
            .Attribute(generator.TypeExpression(debuggerAttributeTypeSymbol), [attributeArgument])
            .WithAdditionalAnnotations(
                Simplifier.Annotation,
                Simplifier.AddImportsAnnotation);

        editor.AddAttribute(type, newAttribute);

        var typeSymbol = (INamedTypeSymbol)semanticModel.GetRequiredDeclaredSymbol(type, cancellationToken);

        if (!typeSymbol.GetMembers().OfType<IMethodSymbol>().Any(IsDebuggerDisplayMethod))
        {
            editor.AddMember(type,
                generator.MethodDeclaration(
                    DebuggerDisplayMethodName,
                    returnType: generator.TypeExpression(SpecialType.System_String),
                    accessibility: Accessibility.Private,
                    statements:
                    [
                        generator.ReturnStatement(generator.InvocationExpression(
                            generator.MemberAccessExpression(
                                generator.ThisExpression(),
                                generator.IdentifierName("ToString"))))
                    ]));
        }

        return document.WithSyntaxRoot(editor.GetChangedRoot());
    }
}