' 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.

Imports Microsoft.CodeAnalysis.Simplification
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax

Namespace Microsoft.CodeAnalysis.VisualBasic.IntroduceVariable
    Partial Friend Class VisualBasicIntroduceVariableService

        Private Class Rewriter
            Inherits VisualBasicSyntaxRewriter

            Private Shared ReadOnly s_replacementAnnotation As New SyntaxAnnotation

            Private ReadOnly _replacementNode As SyntaxNode
            Private ReadOnly _matches As ISet(Of ExpressionSyntax)

            Private Sub New(replacementNode As SyntaxNode, matches As ISet(Of ExpressionSyntax))
                _replacementNode = replacementNode
                _matches = matches
            End Sub

            Public Overrides Function Visit(node As SyntaxNode) As SyntaxNode
                Dim expression = TryCast(node, ExpressionSyntax)
                If expression IsNot Nothing AndAlso _matches.Contains(expression) Then
                    Return _replacementNode.
                        WithLeadingTrivia(expression.GetLeadingTrivia()).
                        WithTrailingTrivia(expression.GetTrailingTrivia()).
                        WithAdditionalAnnotations(s_replacementAnnotation)
                End If

                Return MyBase.Visit(node)
            End Function

            Public Overrides Function VisitParenthesizedExpression(node As ParenthesizedExpressionSyntax) As SyntaxNode
                Dim newNode = MyBase.VisitParenthesizedExpression(node)
                If node IsNot newNode AndAlso newNode.IsKind(SyntaxKind.ParenthesizedExpression) Then
                    Dim parenthesizedExpression = DirectCast(newNode, ParenthesizedExpressionSyntax)
                    Dim innerExpression = parenthesizedExpression.OpenParenToken.GetNextToken().Parent
                    If innerExpression.HasAnnotation(s_replacementAnnotation) AndAlso innerExpression.Equals(parenthesizedExpression.Expression) Then
                        Return newNode.WithAdditionalAnnotations(Simplifier.Annotation)
                    End If
                End If

                Return newNode
            End Function

            Public Overloads Shared Function Visit(node As SyntaxNode, replacementNode As SyntaxNode, matches As ISet(Of ExpressionSyntax)) As SyntaxNode
                Return New Rewriter(replacementNode, matches).Visit(node)
            End Function

            Public Overrides Function VisitInferredFieldInitializer(node As InferredFieldInitializerSyntax) As SyntaxNode
                Dim newNode = DirectCast(MyBase.VisitInferredFieldInitializer(node), InferredFieldInitializerSyntax)
                If newNode IsNot node AndAlso
                   newNode.Expression.HasAnnotation(s_replacementAnnotation) Then

                    Dim inferredName = node.Expression.TryGetInferredMemberName()
                    If inferredName IsNot Nothing Then
                        Return SyntaxFactory.NamedFieldInitializer(
                            SyntaxFactory.IdentifierName(inferredName.EscapeIdentifier(afterDot:=True)),
                            newNode.Expression.WithoutLeadingTrivia()).WithTriviaFrom(newNode)
                    End If
                End If

                Return newNode
            End Function

            Public Overrides Function VisitSimpleArgument(node As SimpleArgumentSyntax) As SyntaxNode
                Dim newNode = DirectCast(MyBase.VisitSimpleArgument(node), SimpleArgumentSyntax)
                If newNode IsNot node AndAlso
                   node.NameColonEquals Is Nothing AndAlso
                   newNode.Expression.HasAnnotation(s_replacementAnnotation) AndAlso
                   TypeOf node.Parent Is TupleExpressionSyntax Then

                    Dim inferredName = node.Expression.TryGetInferredMemberName()
                    If inferredName IsNot Nothing Then
                        Return SyntaxFactory.SimpleArgument(
                            SyntaxFactory.NameColonEquals(SyntaxFactory.IdentifierName(inferredName.EscapeIdentifier())),
                            newNode.Expression.WithoutLeadingTrivia()).WithTriviaFrom(newNode)
                    End If
                End If

                Return newNode
            End Function
        End Class
    End Class
End Namespace