#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "unity.h"
#include "stack.h"

// Hilfsfunktion: int dynamisch anlegen
static int *makeInt(int value)
{
    int *p = (int *)malloc(sizeof(int));
    if (p != NULL)
    {
        *p = value;
    }
    return p;
}

void test_pushAndTopReturnLastPushed(void)
{
    StackNode *stack = NULL;

    int *v1 = makeInt(10);
    int *v2 = makeInt(20);
    int *v3 = makeInt(30);

    TEST_ASSERT_NOT_NULL(v1);
    TEST_ASSERT_NOT_NULL(v2);
    TEST_ASSERT_NOT_NULL(v3);

    stack = push(stack, v1);
    TEST_ASSERT_NOT_NULL(stack);
    TEST_ASSERT_EQUAL_PTR(v1, top(stack));
    TEST_ASSERT_EQUAL_INT(10, *(int *)top(stack));

    stack = push(stack, v2);
    TEST_ASSERT_EQUAL_PTR(v2, top(stack));
    TEST_ASSERT_EQUAL_INT(20, *(int *)top(stack));

    stack = push(stack, v3);
    TEST_ASSERT_EQUAL_PTR(v3, top(stack));
    TEST_ASSERT_EQUAL_INT(30, *(int *)top(stack));

    TEST_ASSERT_EQUAL_PTR(v3, top(stack));
    free(v3);
    stack = pop(stack);

    TEST_ASSERT_EQUAL_PTR(v2, top(stack));
    free(v2);
    stack = pop(stack);

    TEST_ASSERT_EQUAL_PTR(v1, top(stack));
    free(v1);
    stack = pop(stack);

    TEST_ASSERT_NULL(stack);
}

void test_popOnEmptyStackReturnsNull(void)
{
    StackNode *stack = NULL;

    StackNode *newStack = pop(stack);
    TEST_ASSERT_NULL(newStack);

    TEST_ASSERT_NULL(top(newStack));
}

void test_pushAndPopLifoOrder(void)
{
    StackNode *stack = NULL;

    int *v1 = makeInt(1);
    int *v2 = makeInt(2);
    int *v3 = makeInt(3);

    TEST_ASSERT_NOT_NULL(v1);
    TEST_ASSERT_NOT_NULL(v2);
    TEST_ASSERT_NOT_NULL(v3);

    stack = push(stack, v1);
    stack = push(stack, v2);
    stack = push(stack, v3);

    TEST_ASSERT_EQUAL_PTR(v3, top(stack));
    TEST_ASSERT_EQUAL_INT(3, *(int *)top(stack));
    free(v3);
    stack = pop(stack);

    TEST_ASSERT_EQUAL_PTR(v2, top(stack));
    TEST_ASSERT_EQUAL_INT(2, *(int *)top(stack));
    free(v2);
    stack = pop(stack);


    TEST_ASSERT_EQUAL_PTR(v1, top(stack));
    TEST_ASSERT_EQUAL_INT(1, *(int *)top(stack));
    free(v1);
    stack = pop(stack);

    TEST_ASSERT_NULL(stack);
}

void test_topOnEmptyStackReturnsNull(void)
{
    StackNode *stack = NULL;
    TEST_ASSERT_NULL(top(stack));
}

void test_clearStackFreesAllNodes(void)
{
    StackNode *stack = NULL;

    int a = 11;
    int b = 22;
    int c = 33;

    stack = push(stack, &a);
    stack = push(stack, &b);
    stack = push(stack, &c);

    TEST_ASSERT_NOT_NULL(stack);
    TEST_ASSERT_EQUAL_INT(33, *(int *)top(stack));

    clearStack(stack);

    stack = NULL;



}

void setUp(void)
{
  
}

void tearDown(void)
{
  
}

int main(void)
{
    UNITY_BEGIN();

    printf("\n============================\nStack tests\n============================\n");

    RUN_TEST(test_pushAndTopReturnLastPushed);
    RUN_TEST(test_popOnEmptyStackReturnsNull);
    RUN_TEST(test_pushAndPopLifoOrder);
    RUN_TEST(test_topOnEmptyStackReturnsNull);
    RUN_TEST(test_clearStackFreesAllNodes);

    return UNITY_END();
}