// 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.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeRefactorings;
using Microsoft.CodeAnalysis.LanguageService;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Text;
 
namespace Microsoft.CodeAnalysis.SplitOrMergeIfStatements;
 
internal abstract class AbstractSplitIfStatementCodeRefactoringProvider : CodeRefactoringProvider
{
    protected abstract int GetLogicalExpressionKind(ISyntaxKindsService syntaxKinds);
 
    protected abstract CodeAction CreateCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument, string ifKeywordText);
 
    protected abstract Task<SyntaxNode> GetChangedRootAsync(
        Document document,
        SyntaxNode root,
        SyntaxNode ifOrElseIf,
        SyntaxNode leftCondition,
        SyntaxNode rightCondition,
        CancellationToken cancellationToken);
 
    public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
    {
        var (document, textSpan, cancellationToken) = context;
        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
        var token = root.FindToken(textSpan.Start);
 
        if (textSpan.Length > 0 &&
            textSpan != token.Span)
        {
            return;
        }
 
        var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
        var syntaxKinds = document.GetLanguageService<ISyntaxKindsService>();
        var ifGenerator = document.GetLanguageService<IIfLikeStatementGenerator>();
 
        if (IsPartOfBinaryExpressionChain(token, GetLogicalExpressionKind(syntaxKinds), out var rootExpression) &&
            ifGenerator.IsCondition(rootExpression, out var ifOrElseIf))
        {
            context.RegisterRefactoring(
                CreateCodeAction(
                    c => RefactorAsync(document, token.Span, ifOrElseIf.Span, c),
                    syntaxFacts.GetText(syntaxKinds.IfKeyword)),
                ifOrElseIf.Span);
        }
    }
 
    private async Task<Document> RefactorAsync(Document document, TextSpan tokenSpan, TextSpan ifOrElseIfSpan, CancellationToken cancellationToken)
    {
        var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();
        var ifGenerator = document.GetLanguageService<IIfLikeStatementGenerator>();
 
        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
        var token = root.FindToken(tokenSpan.Start);
        var ifOrElseIf = root.FindNode(ifOrElseIfSpan);
 
        Debug.Assert(ifGenerator.IsIfOrElseIf(ifOrElseIf));
 
        var (left, right) = SplitBinaryExpressionChain(token, ifGenerator.GetCondition(ifOrElseIf), syntaxFacts);
 
        var newRoot = await GetChangedRootAsync(document, root, ifOrElseIf, left, right, cancellationToken).ConfigureAwait(false);
        return document.WithSyntaxRoot(newRoot);
    }
 
    private static bool IsPartOfBinaryExpressionChain(SyntaxToken token, int syntaxKind, out SyntaxNode rootExpression)
    {
        // Check whether the token is part of a binary expression, and if so,
        // return the topmost binary expression in the chain (e.g. `a && b && c`).
 
        SyntaxNodeOrToken current = token;
 
        while (current.Parent?.RawKind == syntaxKind)
        {
            current = current.Parent;
        }
 
        rootExpression = current.AsNode();
        return current.IsNode;
    }
 
    private static (SyntaxNode left, SyntaxNode right) SplitBinaryExpressionChain(
        SyntaxToken token, SyntaxNode rootExpression, ISyntaxFactsService syntaxFacts)
    {
        // We have a left-associative binary expression chain, e.g. `a && b && c && d`.
        // Let's say our token is the second `&&` token, between b and c. We'd like to split the chain at this point
        // and build new expressions for the left side and the right side of this token. This will
        // effectively change the associativity from `((a && b) && c) && d` to `(a && b) && (c && d)`.
        // The left side is in the proper shape already and we can build the right side by getting the
        // topmost expression and replacing our parent with our right side. In the example: `(a && b) && c` to `c`.
 
        syntaxFacts.GetPartsOfBinaryExpression(token.Parent, out var parentLeft, out _, out var parentRight);
 
        var left = parentLeft;
        var right = rootExpression.ReplaceNode(token.Parent, parentRight);
 
        return (left, right);
    }
}