// 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.Diagnostics;
using Microsoft.CodeAnalysis.ChangeSignature;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace Microsoft.CodeAnalysis.CSharp.ChangeSignature;

internal readonly struct UnifiedArgumentSyntax : IUnifiedArgumentSyntax
{
    private readonly SyntaxNode _argument;

    private UnifiedArgumentSyntax(SyntaxNode argument)
    {
        Debug.Assert(argument.Kind() is SyntaxKind.Argument or SyntaxKind.AttributeArgument);
        _argument = argument;
    }

    public static IUnifiedArgumentSyntax Create(ArgumentSyntax argument)
        => new UnifiedArgumentSyntax(argument);

    public static IUnifiedArgumentSyntax Create(AttributeArgumentSyntax argument)
        => new UnifiedArgumentSyntax(argument);

    public SyntaxNode NameColon
    {
        get
        {
            return _argument is ArgumentSyntax argument
                ? argument.NameColon
                : ((AttributeArgumentSyntax)_argument).NameColon;
        }
    }

    public IUnifiedArgumentSyntax WithNameColon(SyntaxNode nameColonSyntax)
    {
        Debug.Assert(nameColonSyntax is NameColonSyntax);

        return _argument is ArgumentSyntax argument
            ? Create(argument.WithNameColon((NameColonSyntax)nameColonSyntax))
            : Create(((AttributeArgumentSyntax)_argument).WithNameColon((NameColonSyntax)nameColonSyntax));
    }

    public string GetName()
        => NameColon == null ? string.Empty : ((NameColonSyntax)NameColon).Name.Identifier.ValueText;

    public IUnifiedArgumentSyntax WithName(string name)
    {
        return _argument is ArgumentSyntax argument
                ? Create(argument.WithNameColon(SyntaxFactory.NameColon(SyntaxFactory.IdentifierName(name))))
                : Create(((AttributeArgumentSyntax)_argument).WithNameColon(SyntaxFactory.NameColon(SyntaxFactory.IdentifierName(name))));
    }

    public IUnifiedArgumentSyntax WithAdditionalAnnotations(SyntaxAnnotation annotation)
        => new UnifiedArgumentSyntax(_argument.WithAdditionalAnnotations(annotation));

    public SyntaxNode Expression
    {
        get
        {
            return _argument is ArgumentSyntax argument
                ? argument.Expression
                : ((AttributeArgumentSyntax)_argument).Expression;
        }
    }

    public bool IsDefault
    {
        get
        {
            return _argument == null;
        }
    }

    public bool IsNamed
    {
        get
        {
            return NameColon != null;
        }
    }

    public static explicit operator SyntaxNode(UnifiedArgumentSyntax unified)
        => unified._argument;
}