// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
 
namespace Microsoft.AspNetCore.Razor.Language.Intermediate;
 
public abstract partial class IntermediateNodeWalker
{
    /// <summary>
    ///  Simple stack implementation that fills an array from end-to-start
    ///  to keep the items in the reverse order they were pushed. This ensures
    ///  that they are in the correct order to implement the <see cref="Ancestors"/>
    ///  property.
    /// </summary>
    private struct Stack
    {
        private const int InitialStackSize = 4;
 
        private IntermediateNode[]? _stack;
        private int _stackPointer;
 
        [MemberNotNullWhen(false, nameof(_stack))]
        public readonly bool IsEmpty
            => _stack is null || _stackPointer == _stack.Length;
 
        public readonly ReadOnlySpan<IntermediateNode> Span
            => IsEmpty
                ? ReadOnlySpan<IntermediateNode>.Empty
                : _stack.AsSpan()[_stackPointer..];
 
        public void Push(IntermediateNode node)
        {
            if (_stack is null || _stackPointer == 0)
            {
                Grow();
            }
 
            _stack[--_stackPointer] = node;
        }
 
        public void Pop()
        {
            Debug.Assert(!IsEmpty);
 
            _stack[_stackPointer++] = null!;
        }
 
        [MemberNotNull(nameof(_stack))]
        private void Grow()
        {
            // If we haven't initialized the stack, do so and set the stack pointer.
            if (_stack == null)
            {
                _stack = new IntermediateNode[InitialStackSize];
                _stackPointer = _stack.Length;
                return;
            }
 
            // Otherwise, double the size of the stack and copy the contents over.
 
            Debug.Assert(_stackPointer == 0, "We should only grow the ancestor stack when the stack pointer reaches 0.");
 
            var length = _stack.Length;
            var newStack = new IntermediateNode[length * 2];
 
            _stack.CopyTo(newStack, length);
 
            _stackPointer = length;
            _stack = newStack;
        }
    }
}