#include "unity.h"
#include "bintree.h"
#include <string.h>
#include <stdio.h>

static int compareInt(const void *a, const void *b)
{
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

void setUp(void)
{
}

void tearDown(void)
{
}

/* ============================================================
   TEST 1 — Strings einfügen + korrekte Reihenfolge prüfen
   ============================================================ */

void test_insert_and_retrieve_strings(void)
{
    char *data1 = "a_this";
    char *data2 = "b_is";
    char *data3 = "c_testdata";

    TreeNode *root = addToTree(NULL, data1, strlen(data1) + 1, (CompareFctType)strcmp, NULL);
    addToTree(root, data2, strlen(data2) + 1, (CompareFctType)strcmp, NULL);
    addToTree(root, data3, strlen(data3) + 1, (CompareFctType)strcmp, NULL);

    TEST_ASSERT_EQUAL_STRING(data1, nextTreeData(root));
    TEST_ASSERT_EQUAL_STRING(data2, nextTreeData(NULL));
    TEST_ASSERT_EQUAL_STRING(data3, nextTreeData(NULL));
    TEST_ASSERT_EQUAL_PTR(NULL, nextTreeData(NULL)); // Ende

    clearTree(root);
}

/* ============================================================
   TEST 2 — Integer einfügen + Traversierung
   ============================================================ */

void test_insert_and_retrieve_ints(void)
{
    int a = 2, b = 1, c = 3;

    TreeNode *root = NULL;
    root = addToTree(root, &a, sizeof(int), compareInt, NULL);
    addToTree(root, &b, sizeof(int), compareInt, NULL);
    addToTree(root, &c, sizeof(int), compareInt, NULL);

    int *v1 = nextTreeData(root);
    int *v2 = nextTreeData(NULL);
    int *v3 = nextTreeData(NULL);
    int *v4 = nextTreeData(NULL);

    TEST_ASSERT_EQUAL_INT(1, *v1);
    TEST_ASSERT_EQUAL_INT(2, *v2);
    TEST_ASSERT_EQUAL_INT(3, *v3);
    TEST_ASSERT_NULL(v4);

    clearTree(root);
}

/* ============================================================
   TEST 3 — treeSize korrekt?
   ============================================================ */

void test_tree_size(void)
{
    TreeNode *root = NULL;

    TEST_ASSERT_EQUAL_UINT(0, treeSize(root));

    int x1 = 10, x2 = 5, x3 = 15;
    root = addToTree(root, &x1, sizeof(int), compareInt, NULL);
    addToTree(root, &x2, sizeof(int), compareInt, NULL);
    addToTree(root, &x3, sizeof(int), compareInt, NULL);

    TEST_ASSERT_EQUAL_UINT(3, treeSize(root));

    clearTree(root);
}

/* ============================================================
   TEST 4 — Duplikaterkennung
   ============================================================ */

void test_duplicate_detection(void)
{
    int x = 42;
    int dupFlag = -1;

    TreeNode *root = addToTree(NULL, &x, sizeof(int), compareInt, &dupFlag);
    TEST_ASSERT_EQUAL_INT(0, dupFlag);

    addToTree(root, &x, sizeof(int), compareInt, &dupFlag);
    TEST_ASSERT_EQUAL_INT(1, dupFlag);

    TEST_ASSERT_EQUAL_UINT(1, treeSize(root));

    clearTree(root);
}

/* ============================================================
   TEST 5 — Iterator nach clearTree → sollte NULL liefern
   ============================================================ */

void test_iterator_after_cleartree(void)
{
    int a = 5, b = 1, c = 9;

    TreeNode *root = NULL;
    root = addToTree(root, &a, sizeof(int), compareInt, NULL);
    addToTree(root, &b, sizeof(int), compareInt, NULL);
    addToTree(root, &c, sizeof(int), compareInt, NULL);

    nextTreeData(root);

    clearTree(root);

    TEST_ASSERT_NULL(nextTreeData(NULL));
    TEST_ASSERT_NULL(nextTreeData(NULL));
}

int main(void)
{
    printf("============================\n");
    printf("Bintree tests\n");
    printf("============================\n");

    UNITY_BEGIN();

    RUN_TEST(test_insert_and_retrieve_strings);
    RUN_TEST(test_insert_and_retrieve_ints);
    RUN_TEST(test_tree_size);
    RUN_TEST(test_duplicate_detection);
    RUN_TEST(test_iterator_after_cleartree);

    return UNITY_END();
}