// 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.Threading;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.LanguageService;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.CSharp.Utilities;
using Microsoft.CodeAnalysis.LanguageService;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Shared.Utilities;
using Microsoft.CodeAnalysis.Simplification.Simplifiers;
 
namespace Microsoft.CodeAnalysis.CSharp.Simplification.Simplifiers;
 
internal class MemberAccessExpressionSimplifier : AbstractMemberAccessExpressionSimplifier<
    ExpressionSyntax,
    MemberAccessExpressionSyntax,
    ThisExpressionSyntax>
{
    public static readonly MemberAccessExpressionSimplifier Instance = new();
 
    private MemberAccessExpressionSimplifier()
    {
    }
 
    protected override ISyntaxFacts SyntaxFacts => CSharpSyntaxFacts.Instance;
 
    protected override ISpeculationAnalyzer GetSpeculationAnalyzer(
        SemanticModel semanticModel, MemberAccessExpressionSyntax memberAccessExpression, CancellationToken cancellationToken)
    {
        return new SpeculationAnalyzer(memberAccessExpression, memberAccessExpression.Name, semanticModel, cancellationToken);
    }
 
    protected override bool MayCauseParseDifference(MemberAccessExpressionSyntax memberAccessExpression)
        => ParserWouldTreatReplacementWithNameAsCast(memberAccessExpression);
 
    public static bool ParserWouldTreatReplacementWithNameAsCast(
        MemberAccessExpressionSyntax memberAccessExpression)
    {
        SyntaxNode parent = memberAccessExpression;
        while (true)
        {
            if (parent.IsParentKind(SyntaxKind.SimpleMemberAccessExpression))
            {
                parent = parent.GetRequiredParent();
                continue;
            }
 
            if (!parent.IsParentKind(SyntaxKind.ParenthesizedExpression))
                return false;
 
            break;
        }
 
        // To resolve cast_expression ambiguities, the following rule exists: A sequence of one or more tokens
        // (§6.4) enclosed in parentheses is considered the start of a cast_expression only if at least one of the
        // following are true:
 
        // The sequence of tokens is correct grammar for a type, but not for an expression.
        //
        // The sequence of tokens is correct grammar for a type, and the token immediately following the closing
        // parentheses is the token “~”, the token “!”, the token “(”, an identifier(§6.4.3), a literal(§6.4.5), or
        // any keyword(§6.4.4) except as and is.
 
        // Note: the first cannot be true here.  Because we started with a MemberAccessExpression that we are
        // replacing with it's 'name' portion, this will always be valid as an expression.  So what matters is the
        // second statement.
 
        var parenthesizedExpression = parent.GetRequiredParent();
        var nextToken = parenthesizedExpression.GetLastToken().GetNextToken();
 
        if ((nextToken.Kind() is SyntaxKind.TildeToken or SyntaxKind.ExclamationToken or SyntaxKind.OpenParenToken) ||
            (CSharp.SyntaxFacts.IsKeywordKind(nextToken.Kind()) && nextToken.Kind() is not SyntaxKind.AsKeyword and not SyntaxKind.IsKeyword))
        {
            // This could definitely end up looking like a cast.  See if `The sequence of tokens is correct grammar
            // for a type` holds true here. Note: this check is likely not super accurate.  It probably is missing
            // cases with things like array-syntax or alias-syntax.  But it's likely sufficient for the common case
            // of `this.A.B.C` becoming `A.B.C` which then looks like a type name.
            return IsEntirelySimpleNames(parent.ReplaceNode(memberAccessExpression, memberAccessExpression.Name));
        }
 
        return false;
    }
 
    private static bool IsEntirelySimpleNames(SyntaxNode node)
    {
        return node is MemberAccessExpressionSyntax(SyntaxKind.SimpleMemberAccessExpression) memberAccess
            ? IsEntirelySimpleNames(memberAccess.Expression)
            : node is SimpleNameSyntax;
    }
}