// 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;
using Microsoft.CodeAnalysis.Shared.Extensions;
 
namespace Microsoft.CodeAnalysis.Formatting;
 
/// <summary>
/// it represents a token that is inside of token stream not also outside of token stream
/// 
/// it uses an index to navigate previous and after tokens in the stream to make navigation faster. and regular
/// Previous/NextToken for tokens outside of the stream.
/// 
/// this object is supposed to be live very short but created a lot of time. that is why it is struct. 
/// (same reason why SyntaxToken is struct - to reduce heap allocation)
/// </summary>
internal readonly record struct TokenData : IComparable<TokenData>
{
    public TokenStream TokenStream { get; }
    public int IndexInStream { get; }
    public SyntaxToken Token { get; }
 
    public TokenData(TokenStream tokenStream, int indexInStream, SyntaxToken token)
    {
        Contract.ThrowIfNull(tokenStream);
        Contract.ThrowIfFalse((indexInStream == -1) || (0 <= indexInStream && indexInStream < tokenStream.TokenCount));
 
        this.TokenStream = tokenStream;
        this.IndexInStream = indexInStream;
        this.Token = token;
    }
 
    public TokenData GetPreviousTokenData()
        => this.TokenStream.GetPreviousTokenData(this);
 
    public TokenData GetNextTokenData()
        => this.TokenStream.GetNextTokenData(this);
 
    public override int GetHashCode()
        => this.Token.GetHashCode();
 
    public bool Equals(TokenData other)
    {
        if (this.TokenStream != other.TokenStream)
        {
            return false;
        }
 
        if (this.IndexInStream >= 0 && this.IndexInStream == other.IndexInStream)
        {
            return true;
        }
 
        return this.Token.Equals(other.Token);
    }
 
    public int CompareTo(TokenData other)
    {
        Contract.ThrowIfFalse(this.TokenStream == other.TokenStream);
 
        if (this.IndexInStream >= 0 && other.IndexInStream >= 0)
            return this.IndexInStream - other.IndexInStream;
 
        if (this.Token == other.Token)
            return 0;
 
        var start = this.Token.SpanStart - other.Token.SpanStart;
        if (start != 0)
            return start;
 
        var end = this.Token.Span.End - other.Token.Span.End;
        if (end != 0)
            return end;
 
        // We have two different tokens, which are at the same location.  This can happen with things like empty/missing
        // tokens.  In order to give a strict ordering, we need to walk up the tree to find the first common ancestor
        // and see which token we hit first in that ancestor.
        var commonRoot = this.Token.GetCommonRoot(other.Token);
        Contract.ThrowIfNull(commonRoot);
 
        // Now, figure out the ancestor of each token parented by the common root.
        var thisTokenAncestor = GetAncestorUnderRoot(this.Token, commonRoot);
        var otherTokenAncestor = GetAncestorUnderRoot(other.Token, commonRoot);
 
        foreach (var child in commonRoot.ChildNodesAndTokens())
        {
            if (child == thisTokenAncestor)
                return -1;
            else if (child == otherTokenAncestor)
                return 1;
        }
 
        throw ExceptionUtilities.Unreachable();
 
        static SyntaxNodeOrToken GetAncestorUnderRoot(SyntaxNodeOrToken start, SyntaxNode root)
        {
            var current = start;
            while (current.Parent != root)
                current = current.Parent;
 
            return current;
        }
    }
 
    public static bool operator <(TokenData left, TokenData right)
        => left.CompareTo(right) < 0;
 
    public static bool operator >(TokenData left, TokenData right)
        => left.CompareTo(right) > 0;
}