#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "numbers.h"

// Makro für einfache Test-Prüfung
#define ASSERT_TRUE(condition, message) \
    do { \
        if (!(condition)) { \
            fprintf(stderr, "FEHLER in %s, Zeile %d: %s\n", __FILE__, __LINE__, message); \
            return 0; \
        } \
    } while (0)

// Hilfsfunktion zum Zählen der Elemente eines Arrays, die in einem anderen enthalten sind
static unsigned int count_occurrences(const unsigned int arr[], unsigned int len, unsigned int value) {
    unsigned int count = 0;
    for (unsigned int i = 0; i < len; i++) {
        if (arr[i] == value) {
            count++;
        }
    }
    return count;
}

// Definition der Testfunktionen
int test_createNumbers_basic();
int test_createNumbers_edgeCases();
int test_getDuplicate_findsDuplicate();
int test_getDuplicate_noDuplicateOrEdgeCases();


int test_createNumbers_basic() {
    srand(time(NULL)); 
    unsigned int len = 10;
    unsigned int *arr = createNumbers(len);

    ASSERT_TRUE(arr != NULL, "createNumbers sollte bei len=10 nicht NULL zurueckgeben.");

    unsigned int *temp_copy = (unsigned int *)malloc(len * sizeof(unsigned int));
    if (temp_copy == NULL) return 0;
    memcpy(temp_copy, arr, len * sizeof(unsigned int));
    qsort(temp_copy, len, sizeof(unsigned int), compare_unsigned_int);

    unsigned int unique_count = 0;
    unsigned int duplicate_value = 0;
    
    for (unsigned int i = 0; i < len; i++) {
        if (i == 0 || temp_copy[i] != temp_copy[i-1]) {
            unique_count++;
        }
        if (i > 0 && temp_copy[i] == temp_copy[i-1]) {
            duplicate_value = temp_copy[i];
        }
    }
    
    ASSERT_TRUE(unique_count == len - 1, "Array sollte genau len-1 eindeutige Werte enthalten.");
    ASSERT_TRUE(duplicate_value != 0, "Es sollte genau ein Duplikat gefunden werden.");
    
    free(temp_copy);
    free(arr);
    return 1;
}

int test_createNumbers_edgeCases() {
    // 1. Test mit minimaler Länge (len=2)
    unsigned int len_min = 2; 
    unsigned int *arr_min = createNumbers(len_min);
    ASSERT_TRUE(arr_min != NULL, "createNumbers sollte bei len=2 nicht NULL zurueckgeben.");
    ASSERT_TRUE(getDuplicate(arr_min, len_min) != 0, "Bei len=2 sollte ein Duplikat gefunden werden.");
    free(arr_min);
    
    // 2. Test mit len=0
    unsigned int *arr_zero = createNumbers(0);
    ASSERT_TRUE(arr_zero == NULL, "createNumbers sollte bei len=0 NULL zurueckgeben.");

    // 3. Test mit größerer Länge (len=500)
    unsigned int len_large = 500;
    unsigned int *arr_large = createNumbers(len_large);
    unsigned int duplicate_val = getDuplicate(arr_large, len_large);
    ASSERT_TRUE(count_occurrences(arr_large, len_large, duplicate_val) == 2, "Duplikat sollte genau 2-mal vorkommen.");
    free(arr_large);

    return 1;
}

int test_getDuplicate_findsDuplicate() {
    unsigned int arr1[] = {1, 5, 3, 5, 2};
    unsigned int len1 = 5;
    unsigned int result1 = getDuplicate(arr1, len1);
    ASSERT_TRUE(result1 == 5, "Duplikat 5 sollte gefunden werden.");
    
    unsigned int arr3[] = {10, 20, 30, 40, 10};
    unsigned int len3 = 5;
    unsigned int result3 = getDuplicate(arr3, len3);
    ASSERT_TRUE(result3 == 10, "Duplikat 10 sollte gefunden werden.");
    
    return 1;
}

int test_getDuplicate_noDuplicateOrEdgeCases() {
    // 1. Kein Duplikat
    unsigned int arr1[] = {1, 2, 3, 4};
    unsigned int len1 = 4;
    unsigned int result1 = getDuplicate(arr1, len1);
    ASSERT_TRUE(result1 == 0, "Kein Duplikat sollte 0 zurueckgeben.");

    // 2. Leeres Array
    unsigned int arr2[] = {};
    unsigned int len2 = 0;
    unsigned int result2 = getDuplicate(arr2, len2);
    ASSERT_TRUE(result2 == 0, "Leeres Array sollte 0 zurueckgeben.");

    return 1;
}


// --- Hauptfunktion (Test Runner) ---

typedef int (*test_func)(void);

struct {
    const char *name;
    test_func func;
} tests[] = {
    {"test_createNumbers_basic", test_createNumbers_basic},
    {"test_createNumbers_edgeCases", test_createNumbers_edgeCases},
    {"test_getDuplicate_findsDuplicate", test_getDuplicate_findsDuplicate},
    {"test_getDuplicate_noDuplicateOrEdgeCases", test_getDuplicate_noDuplicateOrEdgeCases},
};

int main(void) {
    int total_tests = sizeof(tests) / sizeof(tests[0]);
    int successful_tests = 0;
    
    printf("Starte %d Unit-Tests...\n", total_tests);
    printf("------------------------------------------\n");

    for (int i = 0; i < total_tests; i++) {
        printf("Teste: %s ... ", tests[i].name);
        fflush(stdout); 
        if (tests[i].func()) {
            printf("PASSED ✅\n");
            successful_tests++;
        } else {
            printf("FAILED ❌\n");
        }
    }

    printf("------------------------------------------\n");
    if (successful_tests == total_tests) {
        printf("ERGEBNIS: ALLE %d TESTS ERFOLGREICH BESTANDEN.\n", total_tests);
        return EXIT_SUCCESS;
    } else {
        printf("ERGEBNIS: %d von %d TESTS FEHLGESCHLAGEN.\n", total_tests - successful_tests, total_tests);
        return EXIT_FAILURE;
    }
}