#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "stack.h"

// Hilfsfunktion: Gibt "PASSED" oder "FAILED" aus
void printTestResult(const char *testName, int passed)
{
    if (passed)
    {
        printf("[PASSED] %s\n", testName);
    }
    else
    {
        printf("[FAILED] %s\n", testName);
    }
}

// Test 1: Leerer Stack
void test_emptyStack()
{
    StackNode *stack = NULL;
    
    // Top auf leerem Stack sollte NULL zurückgeben
    void *result = top(stack);
    printTestResult("Test 1: top() auf leerem Stack", result == NULL);
    
    // Pop auf leerem Stack sollte NULL zurückgeben
    stack = pop(stack);
    printTestResult("Test 1: pop() auf leerem Stack", stack == NULL);
}

// Test 2: Push und Top
void test_pushAndTop()
{
    StackNode *stack = NULL;
    
    // Integer-Werte allokieren
    int *val1 = (int *)malloc(sizeof(int));
    *val1 = 42;
    
    // Wert auf den Stack legen
    stack = push(stack, val1);
    
    // Obersten Wert abrufen
    int *topVal = (int *)top(stack);
    int passed = (topVal != NULL && *topVal == 42);
    printTestResult("Test 2: push() und top()", passed);
    
    // Aufräumen
    free(val1);
    clearStack(stack);
}

//Test 3 mehrmaliges pushen
void test_multiplePush()
{
    StackNode *stack = NULL;
    
    //Speicher für Werte allokieren
    int *val1 = (int *) malloc(sizeof(int));
    int *val2 = (int *) malloc(sizeof(int));
    int *val3 = (int *) malloc(sizeof(int));

    *val1 = 10;
    *val2 = 20;
    *val3 = 30;

    //Testwerte auf den Stack legen
    stack = push(stack, val1);
    stack = push(stack, val2);
    stack = push(stack, val3);

    // Oberster Wert sollte 30 sein (LIFO)
    int *topVal = (int *)top(stack);
    int passed = (topVal != NULL && *topVal == 30);
    printTestResult("Test 3: Mehrfache push() - LIFO-Prinzip", passed);

    // Aufräumen
    free(val1);
    free(val2);
    free(val3);
    clearStack(stack);

}

// Test 4: Push und Pop
void test_pushAndPop()
{
    StackNode *stack = NULL;
    
    // Drei Werte auf den Stack legen
    int *val1 = (int *)malloc(sizeof(int));
    int *val2 = (int *)malloc(sizeof(int));
    int *val3 = (int *)malloc(sizeof(int));
    
    *val1 = 100;
    *val2 = 200;
    *val3 = 300;
    
    stack = push(stack, val1);
    stack = push(stack, val2);
    stack = push(stack, val3);
    
    // Oberster Wert: 300
    int *topVal1 = (int *)top(stack);
    int test1 = (topVal1 != NULL && *topVal1 == 300);
    
    // Pop - neuer oberster Wert: 200
    stack = pop(stack);
    int *topVal2 = (int *)top(stack);
    int test2 = (topVal2 != NULL && *topVal2 == 200);
    
    // Pop - neuer oberster Wert: 100
    stack = pop(stack);
    int *topVal3 = (int *)top(stack);
    int test3 = (topVal3 != NULL && *topVal3 == 100);
    
    // Pop - Stack sollte leer sein
    stack = pop(stack);
    int test4 = (stack == NULL);
    
    int passed = test1 && test2 && test3 && test4;
    printTestResult("Test 4: push() und pop() - Korrekte Reihenfolge", passed);
    
    // Aufräumen
    free(val1);
    free(val2);
    free(val3);
}

// Test 5: ClearStack
void test_clearStack()
{
    StackNode *stack = NULL;
    
    // Mehrere Werte auf den Stack legen
    int *val1 = (int *)malloc(sizeof(int));
    int *val2 = (int *)malloc(sizeof(int));
    int *val3 = (int *)malloc(sizeof(int));
    int *val4 = (int *)malloc(sizeof(int));
    int *val5 = (int *)malloc(sizeof(int));
    
    *val1 = 1;
    *val2 = 2;
    *val3 = 3;
    *val4 = 4;
    *val5 = 5;
    
    stack = push(stack, val1);
    stack = push(stack, val2);
    stack = push(stack, val3);
    stack = push(stack, val4);
    stack = push(stack, val5);
    
    // Stack löschen
    clearStack(stack);
    stack = NULL; // Nach clearStack ist der Stack leer
    
    printTestResult("Test 5: clearStack() - Alle Knoten freigegeben", 1);
    
    // Daten müssen manuell freigegeben werden (Verantwortung des Aufrufers)
    free(val1);
    free(val2);
    free(val3);
    free(val4);
    free(val5);
}

int main()
{
    printf("=== Stack Unit-Tests ===\n\n");
    
    test_emptyStack();
    test_pushAndTop();
    test_multiplePush();
    test_pushAndPop();
    test_clearStack();
    /*test_stressTest();*/
    
    printf("\n=== Alle Tests abgeschlossen ===\n");
    printf("\nCode-Review: Speicherverwaltung\n");
    printf("--------------------------------\n");
    printf("✓ Aufrufer gibt Daten frei, Stack-Funktionen geben Knoten frei\n");
    
    return 0;
}