// 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.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Simplification;

namespace Microsoft.CodeAnalysis.CSharp.Simplification;

using static CSharpInferredMemberNameSimplifier;

internal sealed partial class CSharpInferredMemberNameReducer
{
    private sealed class Rewriter : AbstractReductionRewriter
    {
        public Rewriter(ObjectPool<IReductionRewriter> pool)
            : base(pool)
        {
            s_simplifyTupleName = SimplifyTupleName;
        }

        private readonly Func<ArgumentSyntax, SemanticModel, SimplifierOptions, CancellationToken, ArgumentSyntax> s_simplifyTupleName;

        private ArgumentSyntax SimplifyTupleName(ArgumentSyntax node, SemanticModel semanticModel, SimplifierOptions options, CancellationToken cancellationToken)
        {
            if (CanSimplifyTupleElementName(node, this.ParseOptions))
            {
                return node.WithNameColon(null).WithTriviaFrom(node);
            }

            return node;
        }

        private static readonly Func<AnonymousObjectMemberDeclaratorSyntax, SemanticModel, SimplifierOptions, CancellationToken, SyntaxNode> s_simplifyAnonymousTypeMemberName = SimplifyAnonymousTypeMemberName;

        private static SyntaxNode SimplifyAnonymousTypeMemberName(AnonymousObjectMemberDeclaratorSyntax node, SemanticModel semanticModel, SimplifierOptions options, CancellationToken canellationToken)
        {
            if (CanSimplifyAnonymousTypeMemberName(node))
            {
                return node.WithNameEquals(null).WithTriviaFrom(node);
            }

            return node;
        }

        public override SyntaxNode VisitArgument(ArgumentSyntax node)
        {
            var newNode = base.VisitArgument(node);

            if (node.Parent.IsKind(SyntaxKind.TupleExpression))
            {
                return SimplifyNode(
                    node,
                    newNode: newNode,
                    simplifier: s_simplifyTupleName);
            }

            return newNode;
        }

        public override SyntaxNode VisitAnonymousObjectMemberDeclarator(AnonymousObjectMemberDeclaratorSyntax node)
            => SimplifyNode(
                node,
                newNode: base.VisitAnonymousObjectMemberDeclarator(node),
                simplifier: s_simplifyAnonymousTypeMemberName);
    }
}