PersistentMap/PersistentOrderedMap/BTreeFunctions.cs

using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace PersistentOrderedMap
{
    public static class BTreeFunctions
    {
        // ---------------------------------------------------------
        // Public API
        // ---------------------------------------------------------

        /// <summary>TryGetValue tries to get the value at mapping key. If it finds the key it sets th
        /// out var to value and returns true. </summary>
        public static bool TryGetValue<TK, TV, TStrategy>(Node<TK> root, TK key, TStrategy strategy, out TV value)
            where TStrategy : IKeyStrategy<TK>
        {
            // We always get a strategy to avoid branching already here
            long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;

            Node<TK> current = root;
            while (true)
            {
                if (current.IsLeaf)
                {
                    var leaf = current.AsLeaf<TV>();
                    int index = FindIndex(leaf, key, keyPrefix, strategy);
                    if (index < leaf.Header.Count && strategy.Compare(leaf.Keys![index], key) == 0)
                    {
                        value = leaf.Values[index];
                        return true;
                    }
                    value = default!;
                    return false;
                }
                else
                {
                    var internalNode = current.AsInternal();
                    int index = FindRoutingIndex(internalNode, key, keyPrefix, strategy);
                    current = internalNode.Children[index]!;
                }
            }
        }

        public static Node<TK> Set<TK, TV, TStrategy>(Node<TK> root, TK key, TV value, TStrategy strategy, OwnerId owner, out bool countChanged)
            where TStrategy : IKeyStrategy<TK>
        {
            root = root.EnsureEditable(owner);

            // Todo, this should really be made a tuple return value to not stress the GC
            var (newNode, sep) = InsertRecursive(root, key, value, strategy, owner, out countChanged);

            if (newNode != null)
            {
                var newRoot = strategy.UsesPrefixes 
                    ? new PrefixInternalNode<TK>(owner) 
                    : new InternalNode<TK>(owner);
                
                newRoot.Keys[0] = sep;
                newRoot.Children[0] = root;
                newRoot.Children[1] = newNode;
                newRoot.SetCount(1);
                
                if (strategy.UsesPrefixes)
                {
                    newRoot.AllPrefixes[0] = strategy.GetPrefix(sep);
                }

                return newRoot;
            }

            return root;
        }

        private static (Node<TK>? newNode, TK separator ) InsertRecursive<TK, TV>(Node<TK> node, TK key, TV value, IKeyStrategy<TK> strategy, OwnerId owner, out bool added)
        {
            long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;

            if (node.IsLeaf)
            {
                var leaf = node.AsLeaf<TV>();
                int index = FindIndex(leaf, key, keyPrefix, strategy);

                if (index < leaf.Header.Count && strategy.Compare(leaf.Keys![index], key) == 0)
                {
                    leaf.Values[index] = value;
                    added = false;
                    return (null, default)!;
                }

                added = true;
                if (leaf.Header.Count < LeafNode<TK, TV>.Capacity)
                {
                    InsertIntoLeaf(leaf, index, key, value, strategy);
                    return (null, default)!;
                }
                else
                {
                    return SplitLeaf(leaf, index, key, value, strategy, owner);
                }
            }
            else
            {
                var internalNode = node.AsInternal();
                int index = FindRoutingIndex(internalNode, key, keyPrefix, strategy);

                var child = internalNode.Children[index]!.EnsureEditable(owner);
                internalNode.Children[index] = child;

                var (newNode, sep) = InsertRecursive(child, key, value, strategy, owner, out added);

                if (newNode != null)
                {
                    if (internalNode.Header.Count < InternalNode<TK>.Capacity - 1)
                    {
                        InsertIntoInternal(internalNode, index, sep, newNode, strategy);
                        return (null, default)!;
                    }
                    
                    return SplitInternal(internalNode, index, sep, newNode, strategy, owner);
                    
                }
                return (null, default)!;
            }
        }

        public static Node<TK> Remove<TK, TV, TStrategy>(Node<TK> root, TK key, TStrategy strategy, OwnerId owner, out bool countChanged)
            where TStrategy : IKeyStrategy<TK>
        {
            root = root.EnsureEditable(owner);

            bool rebalanceNeeded = RemoveRecursive<TK, TV, TStrategy>(root, key, strategy, owner, out countChanged);

            if (rebalanceNeeded)
            {
                if (!root.IsLeaf)
                {
                    var internalRoot = root.AsInternal();
                    if (internalRoot.Header.Count == 0)
                    {
                        return internalRoot.Children[0]!;
                    }
                }
            }

            return root;
        }

        private static bool RemoveRecursive<TK, TV, TStrategy>(Node<TK> node, TK key, TStrategy strategy, OwnerId owner, out bool removed)
            where TStrategy : IKeyStrategy<TK>
        {
            long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;

            if (node.IsLeaf)
            {
                var leaf = node.AsLeaf<TV>();
                int index = FindIndex(leaf, key, keyPrefix, strategy);

                if (index < leaf.Header.Count && strategy.Compare(leaf.Keys![index], key) == 0)
                {
                    RemoveFromLeaf(leaf, index, strategy);
                    removed = true;
                    return leaf.Header.Count < LeafNode<TK, TV>.MergeThreshold;
                }

                removed = false;
                return false;
            }
            else
            {
                var internalNode = node.AsInternal();
                int index = FindRoutingIndex(internalNode, key, keyPrefix, strategy);

                var child = internalNode.Children[index]!.EnsureEditable(owner);
                internalNode.Children[index] = child;

                bool childUnderflow = RemoveRecursive<TK, TV, TStrategy>(child, key, strategy, owner, out removed);

                if (removed && childUnderflow)
                {
                    return HandleUnderflow<TK, TV, TStrategy>(internalNode, index, strategy, owner);
                }
                return false;
            }
        }

        // ---------------------------------------------------------
        // Internal Helpers: Search
        // ---------------------------------------------------------

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static int FindIndex<TK,TV, TStrategy>(LeafNode<TK,TV> node, TK key, long keyPrefix, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            if (typeof(TK) == typeof(int))
            {
                Span<TK> keys = node.GetKeys();
                ref TK firstKeyRef = ref MemoryMarshal.GetReference(keys);
                ref int firstIntRef = ref Unsafe.As<TK, int>(ref firstKeyRef);
                ReadOnlySpan<int> intKeys = MemoryMarshal.CreateReadOnlySpan(ref firstIntRef, keys.Length);
                int intKey = Unsafe.As<TK, int>(ref key);
                return IntScanner.FindFirstGreaterOrEqual(intKeys, intKey);
            }
            
            if (strategy.UsesPrefixes)
            {
                int index = PrefixScanner.FindFirstGreaterOrEqual(node.Prefixes, keyPrefix);
                return RefineSearch(index, node.GetKeys(), key, strategy);
            }

            return FallbackSearchKeys(node.GetKeys(), key, strategy);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static int FindRoutingIndex<TK, TStrategy>(InternalNode<TK> node, TK key, long keyPrefix, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {   

            if (typeof(TK) == typeof(int))
            {
                Span<TK> keys = node.GetKeys();
                ref TK firstKeyRef = ref MemoryMarshal.GetReference(keys);
                ref int firstIntRef = ref Unsafe.As<TK, int>(ref firstKeyRef);
                ReadOnlySpan<int> intKeys = MemoryMarshal.CreateReadOnlySpan(ref firstIntRef, keys.Length);
                int intKey = Unsafe.As<TK, int>(ref key);
                return IntScanner.FindFirstGreater(intKeys, intKey);
            }
            if (!strategy.UsesPrefixes)
            {
                return FallbackRoutingKeys(node.GetKeys(), key, strategy);
            }

            int index = PrefixScanner.FindFirstGreaterOrEqual(node.Prefixes, keyPrefix);
            return RefineRouting(index, node.GetKeys(), key, strategy);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int RefineSearch<TK, TStrategy>(int startIndex, ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            int i = startIndex;
            while (i < keys.Length && strategy.Compare(keys[i], key) < 0) i++;
            return i;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int RefineRouting<TK, TStrategy>(int startIndex, ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            int i = startIndex;
            while (i < keys.Length && strategy.Compare(keys[i], key) <= 0) i++;
            return i;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int FallbackSearchKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            return strategy.UseBinarySearch 
                ? BinarySearchKeys(keys, key, strategy) 
                : LinearSearchKeys(keys, key, strategy);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int FallbackRoutingKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            return strategy.UseBinarySearch 
                ? BinaryRoutingKeys(keys, key, strategy) 
                : LinearRoutingKeys(keys, key, strategy);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int LinearSearchKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            int i = 0;
            while (i < keys.Length && strategy.Compare(keys[i], key) < 0) i++;
            return i;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int LinearRoutingKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            int i = 0;
            while (i < keys.Length && strategy.Compare(keys[i], key) <= 0) i++;
            return i;
        }


        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int BinarySearchKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            int low = 0;
            int high = keys.Length - 1;
            ref TK keysRef = ref MemoryMarshal.GetReference(keys);

            while (low <= high)
            {
                int mid = low + ((high - low) >> 1);
                TK midKey = Unsafe.Add(ref keysRef, mid);
                int cmp = strategy.Compare(midKey, key);
        
                if (cmp == 0) return mid;
                if (cmp < 0) low = mid + 1;
                else high = mid - 1;
            }
            return low;
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int BinaryRoutingKeys<TK, TStrategy>(ReadOnlySpan<TK> keys, TK key, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            int low = 0;
            int high = keys.Length - 1;
            ref TK keysRef = ref MemoryMarshal.GetReference(keys);
            
            while (low <= high)
            {
                int mid = low + ((high - low) >> 1);
                TK midKey = Unsafe.Add(ref keysRef, mid);
                int cmp = strategy.Compare(midKey, key);
                
                if (cmp <= 0) low = mid + 1;
                else high = mid - 1;
            }
            return low;
        }
        
        // ---------------------------------------------------------
        // Insertion Logic
        // ---------------------------------------------------------

        private static void InsertIntoLeaf<TK, TV, TStrategy>(LeafNode<TK, TV> leaf, int index, TK key, TV value, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            int count = leaf.Header.Count;
            if (index < count)
            {
                int moveCount = count - index;
                leaf.Keys.AsSpan(index, moveCount).CopyTo(leaf.Keys.AsSpan(index + 1));
                leaf.Values.AsSpan(index, moveCount).CopyTo(leaf.Values.AsSpan(index + 1));

                if (strategy.UsesPrefixes)
                {
                    leaf.AllPrefixes.Slice(index, moveCount).CopyTo(leaf.AllPrefixes.Slice(index + 1));
                }
            }

            leaf.Keys![index] = key;
            leaf.Values[index] = value;

            if (strategy.UsesPrefixes)
            {
                leaf.AllPrefixes[index] = strategy.GetPrefix(key);
            }

            leaf.SetCount(count + 1);
        }

        private static  (Node<TK>, TK) SplitLeaf<TK, TV, TStrategy>(LeafNode<TK, TV> left, int insertIndex, TK key, TV value, TStrategy strategy, OwnerId owner)
            where TStrategy : IKeyStrategy<TK>
        {
            var right = new LeafNode<TK, TV>(owner, strategy.UsesPrefixes);
            int totalCount = left.Header.Count;

            int splitPoint = (insertIndex == totalCount) ? totalCount : (insertIndex == 0 ? 0 : totalCount / 2);
            int moveCount = totalCount - splitPoint;

            if (moveCount > 0)
            {
                left.Keys.AsSpan(splitPoint, moveCount).CopyTo(right.Keys.AsSpan(0));
                left.Values.AsSpan(splitPoint, moveCount).CopyTo(right.Values.AsSpan(0));
                
                if (strategy.UsesPrefixes)
                {
                    left.AllPrefixes.Slice(splitPoint, moveCount).CopyTo(right.AllPrefixes);
                }
            }

            left.SetCount(splitPoint);
            right.SetCount(moveCount);

            if (insertIndex < splitPoint || (splitPoint == 0 && insertIndex == 0))
            {
                InsertIntoLeaf(left, insertIndex, key, value, strategy);
            }
            else
            {
                InsertIntoLeaf(right, insertIndex - splitPoint, key, value, strategy);
            }

            return (right, right.Keys![0]);
        }

        private static void InsertIntoInternal<TK, TStrategy>(InternalNode<TK> node, int index, TK separator, Node<TK> newChild, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            int count = node.Header.Count;

            if (index < count)
            {
                int moveCount = count - index;
                Span<TK> keysSpan = node.Keys;
                keysSpan.Slice(index, moveCount).CopyTo(keysSpan.Slice(index + 1));
                
                Span<Node<TK>> childrenSpan = node.Children!;
                childrenSpan.Slice(index + 1, moveCount).CopyTo(childrenSpan.Slice(index + 2));

                if (strategy.UsesPrefixes)
                {
                    node.AllPrefixes.Slice(index, moveCount).CopyTo(node.AllPrefixes.Slice(index + 1));
                }
            }

            node.Keys[index] = separator;
            node.Children[index + 1] = newChild;
            
            if (strategy.UsesPrefixes)
            {
                node.AllPrefixes[index] = strategy.GetPrefix(separator);
            }

            node.SetCount(count + 1);
        }

        private static (Node<TK>, TK) SplitInternal<TK, TStrategy>(InternalNode<TK> left, int insertIndex, TK separator, Node<TK> newChild, TStrategy strategy, OwnerId owner)
            where TStrategy : IKeyStrategy<TK>
        {
            var right = strategy.UsesPrefixes 
                ? new PrefixInternalNode<TK>(owner) 
                : new InternalNode<TK>(owner);
            
            int count = left.Header.Count;
            int splitPoint = count / 2;
            TK upKey = left.Keys[splitPoint];
            int moveCount = count - splitPoint - 1; 

            if (moveCount > 0)
            {
                Span<TK> leftKeys = left.Keys;
                Span<TK> rightKeys = right.Keys;
                leftKeys.Slice(splitPoint + 1, moveCount).CopyTo(rightKeys); 

                Span<Node<TK>> leftChildren = left.Children!;
                Span<Node<TK>> rightChildren = right.Children!;
                leftChildren.Slice(splitPoint + 1, moveCount + 1).CopyTo(rightChildren);

                if (strategy.UsesPrefixes)
                {
                    left.AllPrefixes.Slice(splitPoint + 1, moveCount).CopyTo(right.AllPrefixes);
                }
            }

            left.SetCount(splitPoint);
            right.SetCount(moveCount);

            if (insertIndex <= splitPoint)
            {
                InsertIntoInternal(left, insertIndex, separator, newChild, strategy);
            }
            else
            {
                InsertIntoInternal(right, insertIndex - (splitPoint + 1), separator, newChild, strategy);
            }

            return (right, upKey);
        }

        // ---------------------------------------------------------
        // Removal Logic
        // ---------------------------------------------------------

        private static void RemoveFromLeaf<TK, TV, TStrategy>(LeafNode<TK, TV> leaf, int index, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            int count = leaf.Header.Count;
            int moveCount = count - index - 1;

            if (moveCount > 0)
            {
                leaf.Keys.AsSpan(index + 1, moveCount).CopyTo(leaf.Keys.AsSpan(index));
                leaf.Values.AsSpan(index + 1, moveCount).CopyTo(leaf.Values.AsSpan(index));

                if (strategy.UsesPrefixes)
                {
                    leaf.AllPrefixes.Slice(index + 1, moveCount).CopyTo(leaf.AllPrefixes.Slice(index));
                }
            }

            leaf.SetCount(count - 1);
        }

        private static bool HandleUnderflow<TK, TV, TStrategy>(InternalNode<TK> parent, int childIndex, TStrategy strategy, OwnerId owner)
            where TStrategy : IKeyStrategy<TK>
        {
            if (childIndex < parent.Header.Count)
            {
                var rightSibling = parent.Children[childIndex + 1]!.EnsureEditable(owner);
                parent.Children[childIndex + 1] = rightSibling;
                var leftChild = parent.Children[childIndex]!;

                if (CanBorrow(rightSibling))
                {
                    RotateLeft<TK, TV, TStrategy>(parent, childIndex, leftChild, rightSibling, strategy);
                    return false;
                }
                else
                {
                    Merge<TK, TV, TStrategy>(parent, childIndex, leftChild, rightSibling, strategy);
                    return parent.Header.Count < LeafNode<TK, TV>.MergeThreshold;
                }
            }
            else if (childIndex > 0)
            {
                var leftSibling = parent.Children[childIndex - 1]!.EnsureEditable(owner);
                parent.Children[childIndex - 1] = leftSibling;
                var rightChild = parent.Children[childIndex]!;

                if (CanBorrow(leftSibling))
                {
                    RotateRight<TK, TV, TStrategy>(parent, childIndex - 1, leftSibling, rightChild, strategy);
                    return false;
                }
                else
                {
                    Merge<TK, TV, TStrategy>(parent, childIndex - 1, leftSibling, rightChild, strategy);
                    return parent.Header.Count < LeafNode<TK, TV>.MergeThreshold;
                }
            }

            return true;
        }

        private static bool CanBorrow<TK>(Node<TK> node)
        {
            return node.Header.Count > 8 + 1;
        }

        private static void Merge<TK, TV, TStrategy>(InternalNode<TK> parent, int separatorIndex, Node<TK> left, Node<TK> right, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            if (left.IsLeaf)
            {
                var leftLeaf = left.AsLeaf<TV>();
                var rightLeaf = right.AsLeaf<TV>();

                int lCount = leftLeaf.Header.Count;
                int rCount = rightLeaf.Header.Count;
                
                rightLeaf.Keys.AsSpan(0, rCount).CopyTo(leftLeaf.Keys.AsSpan(lCount));
                rightLeaf.Values.AsSpan(0, rCount).CopyTo(leftLeaf.Values.AsSpan(lCount));
                
                if (strategy.UsesPrefixes)
                {
                    rightLeaf.AllPrefixes.Slice(0, rCount).CopyTo(leftLeaf.AllPrefixes.Slice(lCount));
                }

                leftLeaf.SetCount(lCount + rCount);
            }
            else
            {
                var leftInternal = left.AsInternal();
                var rightInternal = right.AsInternal();

                TK separator = parent.Keys[separatorIndex];

                int lCount = leftInternal.Header.Count;
                leftInternal.Keys[lCount] = separator;
                
                if (strategy.UsesPrefixes)
                {
                    leftInternal.AllPrefixes[lCount] = strategy.GetPrefix(separator);
                }

                int rCount = rightInternal.Header.Count;
                Span<TK> rightKeys = rightInternal.Keys;
                Span<TK> leftKeys = leftInternal.Keys;
                rightKeys.Slice(0, rCount).CopyTo(leftKeys.Slice(lCount + 1));
                
                if (strategy.UsesPrefixes)
                {
                    rightInternal.AllPrefixes.Slice(0, rCount).CopyTo(leftInternal.AllPrefixes.Slice(lCount + 1));
                }

                Span<Node<TK>> rightChildren = rightInternal.Children!;
                Span<Node<TK>> leftChildren = leftInternal.Children!;
                rightChildren.Slice(0, rCount + 1).CopyTo(leftChildren.Slice(lCount + 1));

                leftInternal.SetCount(lCount + 1 + rCount);
            }

            int pCount = parent.Header.Count;
            int moveCount = pCount - separatorIndex - 1;

            if (moveCount > 0)
            {
                Span<TK> parentKeys = parent.Keys;
                parentKeys.Slice(separatorIndex + 1, moveCount).CopyTo(parentKeys.Slice(separatorIndex));

                if (strategy.UsesPrefixes)
                {
                    parent.AllPrefixes.Slice(separatorIndex + 1, moveCount).CopyTo(parent.AllPrefixes.Slice(separatorIndex));
                }

                Span<Node<TK>> parentChildren = parent.Children!;
                parentChildren.Slice(separatorIndex + 2, moveCount).CopyTo(parentChildren.Slice(separatorIndex + 1));
            }

            parent.SetCount(pCount - 1);
        }

        private static void RotateLeft<TK, TV, TStrategy>(InternalNode<TK> parent, int separatorIndex, Node<TK> left, Node<TK> right, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            if (left.IsLeaf)
            {
                var leftLeaf = left.AsLeaf<TV>();
                var rightLeaf = right.AsLeaf<TV>();

                InsertIntoLeaf(leftLeaf, leftLeaf.Header.Count, rightLeaf.Keys![0], rightLeaf.Values[0], strategy);
                RemoveFromLeaf(rightLeaf, 0, strategy);

                parent.Keys[separatorIndex] = rightLeaf.Keys[0];
                if (strategy.UsesPrefixes)
                {
                    parent.AllPrefixes[separatorIndex] = strategy.GetPrefix(rightLeaf.Keys[0]);
                }
            }
            else
            {
                var leftInternal = left.AsInternal();
                var rightInternal = right.AsInternal();

                TK sep = parent.Keys[separatorIndex];
                InsertIntoInternal(leftInternal, leftInternal.Header.Count, sep, rightInternal.Children[0]!, strategy);

                parent.Keys[separatorIndex] = rightInternal.Keys[0];
                if (strategy.UsesPrefixes)
                {
                    parent.AllPrefixes[separatorIndex] = strategy.GetPrefix(rightInternal.Keys[0]);
                }

                int rCount = rightInternal.Header.Count;

                Span<Node<TK>> rightChildren = rightInternal.Children!;
                rightChildren.Slice(1, rCount).CopyTo(rightChildren);

                if (rCount > 1)
                {
                    Span<TK> rightKeys = rightInternal.Keys;
                    rightKeys.Slice(1, rCount - 1).CopyTo(rightKeys); 

                    if (strategy.UsesPrefixes)
                    {
                        rightInternal.AllPrefixes.Slice(1, rCount - 1).CopyTo(rightInternal.AllPrefixes);
                    }
                }

                rightInternal.SetCount(rCount - 1);
            }
        }

        private static void RotateRight<TK, TV, TStrategy>(InternalNode<TK> parent, int separatorIndex, Node<TK> left, Node<TK> right, TStrategy strategy)
            where TStrategy : IKeyStrategy<TK>
        {
            if (left.IsLeaf)
            {
                var leftLeaf = left.AsLeaf<TV>();
                var rightLeaf = right.AsLeaf<TV>();
                int last = leftLeaf.Header.Count - 1;

                InsertIntoLeaf(rightLeaf, 0, leftLeaf.Keys![last], leftLeaf.Values[last], strategy);
                RemoveFromLeaf(leftLeaf, last, strategy);

                parent.Keys[separatorIndex] = rightLeaf.Keys![0];
                if (strategy.UsesPrefixes)
                {
                    parent.AllPrefixes[separatorIndex] = strategy.GetPrefix(rightLeaf.Keys[0]);
                }
            }
            else
            {
                var leftInternal = left.AsInternal();
                var rightInternal = right.AsInternal();
                int last = leftInternal.Header.Count - 1;

                TK sep = parent.Keys[separatorIndex];
                InsertIntoInternal(rightInternal, 0, sep, leftInternal.Children[last + 1]!, strategy);

                parent.Keys[separatorIndex] = leftInternal.Keys[last];
                if (strategy.UsesPrefixes)
                {
                    parent.AllPrefixes[separatorIndex] = strategy.GetPrefix(leftInternal.Keys[last]);
                }

                leftInternal.SetCount(last);
            }
        }

        public static bool TryGetMin<TK, TV>(Node<TK> root, out TK key, out TV value)
        {
            var current = root;
            while (!current.IsLeaf)
            {
                current = current.AsInternal().Children[0]!;
            }

            var leaf = current.AsLeaf<TV>();
            if (leaf.Header.Count == 0)
            {
                key = default!;
                value = default!;
                return false;
            }

            key = leaf.Keys![0];
            value = leaf.Values[0];
            return true;
        }

        public static bool TryGetMax<TK, TV>(Node<TK> root, out TK key, out TV value)
        {
            var current = root;
            while (!current.IsLeaf)
            {
                var internalNode = current.AsInternal();
                current = internalNode.Children[internalNode.Header.Count]!;
            }

            var leaf = current.AsLeaf<TV>();
            if (leaf.Header.Count == 0)
            {
                key = default!;
                value = default!;
                return false;
            }

            int last = leaf.Header.Count - 1;
            key = leaf.Keys![last];
            value = leaf.Values[last];
            return true;
        }

        public static bool TryGetSuccessor<TK, TV, TStrategy>(Node<TK> root, TK key, TStrategy strategy, out TK nextKey, out TV nextValue)
            where TStrategy : IKeyStrategy<TK>
        {
            InternalNode<TK>[] path = new InternalNode<TK>[32];
            int[] indices = new int[32];
            int depth = 0;
            long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;

            var current = root;
            while (!current.IsLeaf)
            {
                var internalNode = current.AsInternal();
                int idx = FindRoutingIndex(internalNode, key, keyPrefix, strategy);
                path[depth] = internalNode;
                indices[depth] = idx;
                depth++;
                current = internalNode.Children[idx]!;
            }

            var leaf = current.AsLeaf<TV>();
            int index = FindIndex(leaf, key, keyPrefix, strategy);

            if (index < leaf.Header.Count && strategy.Compare(leaf.Keys![index], key) == 0) index++;

            if (index < leaf.Header.Count)
            {
                nextKey = leaf.Keys![index];
                nextValue = leaf.Values[index];
                return true;
            }

            for (int i = depth - 1; i >= 0; i--)
            {
                if (indices[i] < path[i].Header.Count)
                {
                    current = path[i].Children[indices[i] + 1]!;
                    while (!current.IsLeaf)
                    {
                        current = current.AsInternal().Children[0]!;
                    }

                    var targetLeaf = current.AsLeaf<TV>();
                    nextKey = targetLeaf.Keys![0];
                    nextValue = targetLeaf.Values[0];
                    return true;
                }
            }

            nextKey = default!;
            nextValue = default!;
            return false;
        }

        public static bool TryGetPredecessor<TK, TV, TStrategy>(Node<TK> root, TK key, TStrategy strategy, out TK prevKey, out TV prevValue)
            where TStrategy : IKeyStrategy<TK>
        {
            InternalNode<TK>[] path = new InternalNode<TK>[32];
            int[] indices = new int[32];
            int depth = 0;
            long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;

            var current = root;
            while (!current.IsLeaf)
            {
                var internalNode = current.AsInternal();
                int idx = FindRoutingIndex(internalNode, key, keyPrefix, strategy);
                path[depth] = internalNode;
                indices[depth] = idx;
                depth++;
                current = internalNode.Children[idx]!;
            }

            var leaf = current.AsLeaf<TV>();
            int index = FindIndex(leaf, key, keyPrefix, strategy);

            if (index > 0)
            {
                prevKey = leaf.Keys![index - 1];
                prevValue = leaf.Values[index - 1];
                return true;
            }

            for (int i = depth - 1; i >= 0; i--)
            {
                if (indices[i] > 0)
                {
                    current = path[i].Children[indices[i] - 1]!;
                    while (!current.IsLeaf)
                    {
                        var internalNode = current.AsInternal();
                        current = internalNode.Children[internalNode.Header.Count]!;
                    }

                    var targetLeaf = current.AsLeaf<TV>();
                    int last = targetLeaf.Header.Count - 1;
                    prevKey = targetLeaf.Keys![last];
                    prevValue = targetLeaf.Values[last];
                    return true;
                }
            }

            prevKey = default!;
            prevValue = default!;
            return false;
        }
    }
}