// 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.Collections.Generic;
using Microsoft.CodeAnalysis.CSharp.Syntax;
 
namespace Microsoft.CodeAnalysis.CSharp.Utilities;
 
internal class NameSyntaxComparer : IComparer<NameSyntax?>
{
    private readonly IComparer<SyntaxToken> _tokenComparer;
    internal readonly TypeSyntaxComparer TypeComparer;
 
    internal NameSyntaxComparer(IComparer<SyntaxToken> tokenComparer)
    {
        _tokenComparer = tokenComparer;
        TypeComparer = new TypeSyntaxComparer(tokenComparer, this);
    }
 
    public static IComparer<NameSyntax?> Create()
        => Create(TokenComparer.NormalInstance);
 
    public static IComparer<NameSyntax?> Create(IComparer<SyntaxToken> tokenComparer)
        => new NameSyntaxComparer(tokenComparer);
 
    public int Compare(NameSyntax? x, NameSyntax? y)
    {
        if (x == y)
            return 0;
 
        return (x, y) switch
        {
            (null, null) => 0,
            (null, _) => -1,
            (_, null) => 1,
            ({ IsMissing: true }, { IsMissing: true }) => 0,
            ({ IsMissing: true }, _) => -1,
            (_, { IsMissing: true }) => 1,
            (IdentifierNameSyntax identifierX, IdentifierNameSyntax identifierY) => _tokenComparer.Compare(identifierX.Identifier, identifierY.Identifier),
            (GenericNameSyntax genericX, GenericNameSyntax genericY) => Compare(genericX, genericY),
            (IdentifierNameSyntax identifierX, GenericNameSyntax genericY) =>
                _tokenComparer.Compare(identifierX.Identifier, genericY.Identifier) is var diff && diff != 0
                    ? diff
                    : -1, // Goo goes before Goo<T>
            (GenericNameSyntax genericX, IdentifierNameSyntax identifierY) =>
                _tokenComparer.Compare(genericX.Identifier, identifierY.Identifier) is var diff && diff != 0
                    ? diff
                    : -1, // Goo<T> goes after Goo
            (_, _) => DecomposeCompare(x, y),
        };
 
        int DecomposeCompare(NameSyntax x, NameSyntax y)
        {
            // At this point one or both of the nodes is a dotted name or
            // aliased name.  Break them apart into individual pieces and
            // compare those.
 
            var xNameParts = DecomposeNameParts(x);
            var yNameParts = DecomposeNameParts(y);
 
            for (var i = 0; i < xNameParts.Count && i < yNameParts.Count; i++)
            {
                var compare = Compare(xNameParts[i], yNameParts[i]);
                if (compare != 0)
                    return compare;
            }
 
            // they matched up to this point.  The shorter one should come
            // first.
            return xNameParts.Count - yNameParts.Count;
        }
    }
 
    private static IList<SimpleNameSyntax> DecomposeNameParts(NameSyntax name)
    {
        var result = new List<SimpleNameSyntax>();
        DecomposeNameParts(name, result);
        return result;
    }
 
    private static void DecomposeNameParts(NameSyntax name, List<SimpleNameSyntax> result)
    {
        switch (name.Kind())
        {
            case SyntaxKind.QualifiedName:
                var dottedName = (QualifiedNameSyntax)name;
                DecomposeNameParts(dottedName.Left, result);
                DecomposeNameParts(dottedName.Right, result);
                break;
            case SyntaxKind.AliasQualifiedName:
                var aliasedName = (AliasQualifiedNameSyntax)name;
                result.Add(aliasedName.Alias);
                DecomposeNameParts(aliasedName.Name, result);
                break;
            case SyntaxKind.IdentifierName:
                result.Add((IdentifierNameSyntax)name);
                break;
            case SyntaxKind.GenericName:
                result.Add((GenericNameSyntax)name);
                break;
        }
    }
 
    private int Compare(GenericNameSyntax x, GenericNameSyntax y)
    {
        var compare = _tokenComparer.Compare(x.Identifier, y.Identifier);
        if (compare != 0)
            return compare;
 
        // The one with less type params comes first.
        compare = x.Arity - y.Arity;
        if (compare != 0)
            return compare;
 
        // Same name, same parameter count.  Compare each parameter.
        for (var i = 0; i < x.Arity; i++)
        {
            var xArg = x.TypeArgumentList.Arguments[i];
            var yArg = y.TypeArgumentList.Arguments[i];
 
            compare = TypeComparer.Compare(xArg, yArg);
            if (compare != 0)
                return compare;
        }
 
        return 0;
    }
}