#include <bits/types/stack_t.h>
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"

/*
 * Gibt den gesamten Stack von oben (Top) nach unten aus.
 * Erwartet einen Zeiger auf den obersten StackNode.
 * Die Funktion verändert den Stack nicht dauerhaft,
 * da der lokale Zeiger 'stack' nur kopiert wird.
 */
void inspectStack(StackNode *stack)
{    
    if (stack != NULL)
    {
        //Erstes Element separat ausgeben, um kein führendes Leerzeichen zu haben
        printf("Der Stack enthält die folgenden Elemente: %d", *(int*)stack->value);

        // Über die verkettete Liste iterieren
        while (stack->next != NULL)
        {
            printf(" %d", *(int*)stack->next->value);
            stack = stack->next;  // zum nächsten Element wechseln
        }
        putchar('\n');
    }
    else
    {
        // Leerer Stack (NULL-Zeiger)
        printf("Der Stack ist leer\n");
    }
}

int main()
{
    // Zeiger auf den obersten Stack-Knoten
    StackNode *stack;

    // Initialisierung: NULL entspricht einem leeren Stack 
    stack = NULL;
    
    printf("...ein Element wird eingefügt...\n");

    /*
     * Achtung: Es wird die Adresse von 'toBeRemoved' gespeichert.
     * Das ist hier zulässig, da die Variable bis zum Ende von main
     * gültig bleibt. In allgemeinem Code sollte man stattdessen
     * dynamisch Speicher reservieren oder den Wert kopieren.
     */
    int toBeRemoved = 42;
    stack = push(stack, &toBeRemoved);
    
    inspectStack(stack);

    printf("...das Element wird wieder entfernt...\n");

    // pop gibt den neuen Stack-Top zurück
    stack = pop(stack);
    
    inspectStack(stack);
    
    printf("...pop auf leeren Stack...\n");

    // pop auf leerem Stack sollte intern sicher behandelt werden
    stack = pop(stack);
    
    inspectStack(stack);
    putchar('\n');

    // Statisches Array mit Beispieldaten 
    int data[5] = {1, 2, 3, 4, 5};

    /*
     * Alle 5 Werte der Reihe nach auf den Stack legen:
     * 1 liegt unten, 5 liegt oben (LIFO-Prinzip).
     */
    for (int i = 0; i < 5; i++)
    {
        stack = push(stack, &data[i]);
    }

    /* Gesamten Stack ausgeben */
    inspectStack(stack);
    
    /*
     * Elemente einzeln auslesen (top) und anschließend entfernen (pop).
     * Erwartete Ausgabe-Reihenfolge: 5, 4, 3, 2, 1
     */
    printf("1. Element war: %d\n", *(int*)top(stack));
    stack = pop(stack);

    printf("2. Element war: %d\n", *(int*)top(stack));
    stack = pop(stack);

    printf("3. Element war: %d\n", *(int*)top(stack));
    stack = pop(stack);

    printf("4. Element war: %d\n", *(int*)top(stack));
    stack = pop(stack);

    printf("5. Element war: %d\n", *(int*)top(stack));

    /*
     * Hinweis: Nach dem letzten top() sollte eigentlich noch
     * ein pop() erfolgen, um den Stack vollständig zu leeren
     * und ggf. dynamisch allokierten Speicher freizugeben.
     */
}

/*
int main()
{
    UNITY_BEGIN();

    printf("============================\n Stack tests\n============================\n");
    RUN_TEST(test_createNodeFailsOnZeroData);

    return UNITY_END();
}
*/