package com.thealgorithms.stacks;

import java.util.Stack;

/**
 * A utility class that provides a method to sort a stack using recursion.
 * The elements are sorted in ascending order, with the largest element at the top.
 * This algorithm is implemented using only recursion and the original stack,
 * without utilizing any additional data structures apart from the stack itself.
 */
public final class SortStack {
    private SortStack() {
    }

    /**
     * Sorts the given stack in ascending order using recursion.
     * The sorting is performed such that the largest element ends up on top of the stack.
     * This method modifies the original stack and does not return a new stack.
     *
     * The algorithm works as follows:
     * 1. Remove the top element.
     * 2. Recursively sort the remaining stack.
     * 3. Insert the removed element back into the sorted stack at the correct position.
     *
     * @param stack The stack to be sorted, containing Integer elements.
     * @throws IllegalArgumentException if the stack contains `null` elements.
     */
    public static void sortStack(Stack<Integer> stack) {
        if (stack.isEmpty()) {
            return;
        }

        int top = stack.pop();
        sortStack(stack);
        insertInSortedOrder(stack, top);
    }

    /**
     * Helper method to insert an element into the correct position in a sorted stack.
     * This method is called recursively to place the given element into the stack
     * such that the stack remains sorted in ascending order.
     *
     * The element is inserted in such a way that all elements below it are smaller
     * (if the stack is non-empty), and elements above it are larger, maintaining
     * the ascending order.
     *
     * @param stack The stack in which the element needs to be inserted.
     * @param element The element to be inserted into the stack in sorted order.
     */
    private static void insertInSortedOrder(Stack<Integer> stack, int element) {
        if (stack.isEmpty() || element > stack.peek()) {
            stack.push(element);
            return;
        }

        int top = stack.pop();
        insertInSortedOrder(stack, element);
        stack.push(top);
    }
}