// 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 Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.CSharp.Simplification;
 
internal static class CSharpInferredMemberNameSimplifier
{
    internal static bool CanSimplifyTupleElementName(ArgumentSyntax node, CSharpParseOptions parseOptions)
    {
        // Tuple elements are arguments in a tuple expression
        if (node.NameColon == null || !node.Parent.IsKind(SyntaxKind.TupleExpression))
        {
            return false;
        }
 
        if (parseOptions.LanguageVersion < LanguageVersion.CSharp7_1)
        {
            return false;
        }
 
        if (RemovalCausesAmbiguity(((TupleExpressionSyntax)node.Parent).Arguments, node))
        {
            return false;
        }
 
        var inferredName = node.Expression.TryGetInferredMemberName();
        if (inferredName == null || inferredName != node.NameColon.Name.Identifier.ValueText)
        {
            return false;
        }
 
        return true;
    }
 
    internal static bool CanSimplifyAnonymousTypeMemberName(AnonymousObjectMemberDeclaratorSyntax node)
    {
        if (node.NameEquals == null)
        {
            return false;
        }
 
        if (RemovalCausesAmbiguity(((AnonymousObjectCreationExpressionSyntax)node.Parent!).Initializers, node))
        {
            return false;
        }
 
        var inferredName = node.Expression.TryGetInferredMemberName();
        if (inferredName == null || inferredName != node.NameEquals.Name.Identifier.ValueText)
        {
            return false;
        }
 
        return true;
    }
 
    // An explicit name cannot be removed if some other position would produce it as inferred name
    private static bool RemovalCausesAmbiguity(SeparatedSyntaxList<ArgumentSyntax> arguments, ArgumentSyntax toRemove)
    {
        Contract.ThrowIfNull(toRemove.NameColon);
 
        var name = toRemove.NameColon.Name.Identifier.ValueText;
        foreach (var argument in arguments)
        {
            if (argument == toRemove)
            {
                continue;
            }
 
            if (argument.NameColon is null && argument.Expression.TryGetInferredMemberName()?.Equals(name) == true)
            {
                return true;
            }
        }
 
        return false;
    }
 
    // An explicit name cannot be removed if some other position would produce it as inferred name
    private static bool RemovalCausesAmbiguity(SeparatedSyntaxList<AnonymousObjectMemberDeclaratorSyntax> initializers, AnonymousObjectMemberDeclaratorSyntax toRemove)
    {
        Contract.ThrowIfNull(toRemove.NameEquals);
 
        var name = toRemove.NameEquals.Name.Identifier.ValueText;
        foreach (var initializer in initializers)
        {
            if (initializer == toRemove)
            {
                continue;
            }
 
            if (initializer.NameEquals is null && initializer.Expression.TryGetInferredMemberName()?.Equals(name) == true)
            {
                return true;
            }
        }
 
        return false;
    }
}