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

int compareInts(const void *arg1, const void *arg2){
    int val1 = *(int *)arg1;
    int val2 = *(int *)arg2;

    if(val1 < val2) return -1;
    if(val1 > val2) return 1;
    return 0;
}

int compareStrings(const void *arg1, const void *arg2){
    return -strcmp((const char *)arg1, (const char *)arg2);
}


void setUp(void){
    //Use if needed    
}
void tearDown(void){
    //Use if needed
}

void test_addToTree_singleElement(void){
    int value = 42;
    TreeNode *tree = NULL;

    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);

    TEST_ASSERT_NOT_NULL(tree);
    TEST_ASSERT_EQUAL_INT(value, *(int *)tree->data);
    TEST_ASSERT_NULL(tree->left);
    TEST_ASSERT_NULL(tree->right);
}

void test_addToTree_multipleElements(void){
    TreeNode *tree = NULL;
    int values[] = {20, 30, 40, 50, 60, 70, 80};

    for(int i = 0; i < 7; i++){
        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
    }

    TEST_ASSERT_NOT_NULL(tree);
    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->data);
    TEST_ASSERT_EQUAL_INT(30, *(int *)tree->right->data);
    TEST_ASSERT_EQUAL_INT(40, *(int *)tree->right->right->data);
    TEST_ASSERT_EQUAL_INT(50, *(int *)tree->right->right->right->data);
    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->right->right->right->data);
}

void test_addToTree_multipleElementsOptimised(void){
    TreeNode *tree = NULL;
    int values[] = {50, 30, 70, 20, 40, 60, 80};

    for(int i = 0; i < 7; i++){
        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
    }

    TEST_ASSERT_NOT_NULL(tree);
    TEST_ASSERT_EQUAL_INT(50, *(int *)tree->data);
    TEST_ASSERT_EQUAL_INT(30, *(int *)tree->left->data);
    TEST_ASSERT_EQUAL_INT(70, *(int *)tree->right->data);
    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->data);
    TEST_ASSERT_EQUAL_INT(40, *(int *)tree->left->right->data);
}

void test_addToTree_withDuplicatesAccept(void){
    TreeNode *tree = NULL;
    int values[] = {50, 30, 70, 20, 20, 60, 60};

    for(int i = 0; i < 7; i++){
        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
    }

    TEST_ASSERT_NOT_NULL(tree);

    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->data);
    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->right->data);
    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->left->data);
    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->left->right->data);
}

void test_addToTree_withoutDuplicatesAccept(void){
    TreeNode *tree = NULL;
    int values[] = {50, 30, 70, 20, 20, 60, 60};
    int isDuplicate = 0;

    for(int i = 0; i < 7; i++){
        tree = addToTree(tree, &values[i], sizeof(int), compareInts, &isDuplicate);
        if(i == 4 || i == 6){
            TEST_ASSERT_EQUAL_INT(1, isDuplicate);
        } else{
            TEST_ASSERT_EQUAL_INT(0, isDuplicate);
        }
    }

    TEST_ASSERT_NOT_NULL(tree);
    TEST_ASSERT_EQUAL_INT(20, *(int *)tree->left->left->data);
    TEST_ASSERT_EQUAL_INT(60, *(int *)tree->right->left->data);
    TEST_ASSERT_EQUAL_INT(5, treeSize(tree));
}
void test_treeSize_emptyTree(void){
    
    TEST_ASSERT_EQUAL_UINT(0, treeSize(NULL));
}

void test_treeSize_singleNode(void){
    TreeNode *tree = NULL;
    int value = 42;
    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);

    TEST_ASSERT_NOT_NULL(tree);
    TEST_ASSERT_EQUAL_UINT(1, treeSize(tree));
}

void test_treeSize_multipleNodes(void){
    TreeNode *tree = NULL;
    int values[] = {50, 30, 70, 20, 40, 60, 80};

    for(int i = 0; i < 7; i++){
        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
    }


    TEST_ASSERT_NOT_NULL(tree);
    TEST_ASSERT_EQUAL_UINT(7, treeSize(tree));

}

void test_nextTreeData_emptyTree(void){
    TEST_ASSERT_NULL(nextTreeData(NULL));
}

void test_clearTree_emptyTree(void){
    clearTree(NULL);
    TEST_ASSERT_TRUE(1);
}

void test_clearTree_singleElement(void){
    int value = 42;
    TreeNode *tree = NULL;

    tree = addToTree(tree, &value, sizeof(int), compareInts, NULL);

    clearTree(tree);

    TEST_ASSERT_TRUE(1);
}

void test_clearTree_multipleElements(void){
    TreeNode *tree = NULL;
    int values[] = {50, 30, 70, 20, 40, 60, 80};

    for(int i = 0; i < 7; i++){
        tree = addToTree(tree, &values[i], sizeof(int), compareInts, NULL);
    }

    clearTree(tree);

    TEST_ASSERT_TRUE(1);
}
int main(){
    UNITY_BEGIN();

    printf("\n============================\nBintree tests\n============================\n");
    
    //addToTree()
    RUN_TEST(test_addToTree_singleElement);
    RUN_TEST(test_addToTree_multipleElements);
    RUN_TEST(test_addToTree_multipleElementsOptimised);
    RUN_TEST(test_addToTree_withDuplicatesAccept);
    RUN_TEST(test_addToTree_withoutDuplicatesAccept);

    //treeSize()
    RUN_TEST(test_treeSize_emptyTree);
    RUN_TEST(test_treeSize_singleNode);
    RUN_TEST(test_treeSize_multipleNodes);

    //nextTreeData()

    RUN_TEST(test_nextTreeData_emptyTree);

    //clearTree()
    RUN_TEST(test_clearTree_emptyTree);
    RUN_TEST(test_clearTree_singleElement);
    RUN_TEST(test_clearTree_multipleElements);

    return UNITY_END();
    
}