#include <stdio.h>
#include <stdlib.h>
#include "numbers.h"
#include "unity.h"
#include <stdbool.h>

//Initialisierung
void setUp(void){}
void tearDown(void){}

// Hilfsfunktion: zählt Vorkommen eines Werts
static unsigned int countOccurrences(unsigned int* arr, unsigned int n, unsigned int value)
{
    unsigned int count = 0;
    for (unsigned int i = 0; i < n; i++)
        if (arr[i] == value)
            count++;
    return count;
}

// ---------------------------------------------------------------------------
// Test 1: createNumbers erzeugt ein Array der richtigen Größe
// ---------------------------------------------------------------------------
void test_createNumbers_returns_valid_array(void)
{
    unsigned int n = 50;
    unsigned int* arr = createNumbers(n);

    TEST_ASSERT_NOT_NULL(arr);

    // Ein paar Werte prüfen (dürfen alles sein, nur kein Segfault)
    for (unsigned int i = 0; i < n; i++)
        TEST_ASSERT_TRUE(arr[i] >= 0);

    free(arr);
}

// ---------------------------------------------------------------------------
// Test 2: createNumbers erzeugt GENAU EIN Duplikat
// ---------------------------------------------------------------------------
void test_createNumbers_contains_exactly_one_duplicate(void)
{
    unsigned int n = 50;
    unsigned int* arr = createNumbers(n);

    TEST_ASSERT_NOT_NULL(arr);

    // zähle wie viele Werte doppelt vorkommen
    unsigned int duplicateValue = 0;
    unsigned int totalDuplicateAppearances = 0;

    for (unsigned int i = 0; i < n; i++)
    {
        unsigned int c = countOccurrences(arr, n, arr[i]);
        if (c == 2)   // genau zweimal → Bestandteil des Duplikats
        {
            duplicateValue = arr[i];
            totalDuplicateAppearances++;
        }
    }

    // Wenn genau eine Zahl doppelt vorkommt,
    // finden wir sie zweimal → totalDuplicateAppearances == 2
    TEST_ASSERT_EQUAL_UINT(2, totalDuplicateAppearances);

    free(arr);
}
// ---------------------------------------------------------------------------
// Test 3: getDuplicated findet genau die richtige doppelte Zahl
// ---------------------------------------------------------------------------
void test_getDuplicated_finds_correct_duplicate(void)
{
    unsigned int n = 50;
    unsigned int* arr = createNumbers(n);
    TEST_ASSERT_NOT_NULL(arr);

    // Ermittle das Duplikat manuell
    unsigned int expected = 0;

    for (unsigned int i = 0; i < n; i++)
    {
        if (countOccurrences(arr, n, arr[i]) == 2)
        {
            expected = arr[i];
            break;
        }
    }

    unsigned int result = getDuplicate(arr, n);

    TEST_ASSERT_EQUAL_UINT(expected, result);

    free(arr);
}

// ---------------------------------------------------------------------------
// Hilfsfunktion: prüft ob createNumbers einen Fehlerzustand signalisiert
// Du kannst diese später anpassen (z.B. wenn Fehler-Flags eingebaut werden)
// ---------------------------------------------------------------------------
static bool did_createNumbers_fail(unsigned int* ptr)
{
    return (ptr == NULL);   // aktuell: NULL bedeutet Fehler
}


// ---------------------------------------------------------------------------
// Test: createNumbers soll bei count < 2 fehlschlagen
// ---------------------------------------------------------------------------
void test_createNumbers_rejects_too_small_counts(void)
{
    unsigned int* r1 = createNumbers(0);
    unsigned int* r2 = createNumbers(1);

    TEST_ASSERT_TRUE(did_createNumbers_fail(r1));
    TEST_ASSERT_TRUE(did_createNumbers_fail(r2));
}


// ---------------------------------------------------------------------------
// Test: createNumbers(2) soll funktionieren (Minimum gültiger Input)
// ---------------------------------------------------------------------------
void test_createNumbers_with_two_elements_is_valid(void)
{
    unsigned int* arr = createNumbers(2);

    TEST_ASSERT_FALSE(did_createNumbers_fail(arr));
    TEST_ASSERT_NOT_NULL(arr);

    // should contain exactly one duplicate
    unsigned int c0 = countOccurrences(arr, 2, arr[0]);
    unsigned int c1 = countOccurrences(arr, 2, arr[1]);

    TEST_ASSERT_TRUE((c0 == 2) || (c1 == 2));

    free(arr);
}


// ---------------------------------------------------------------------------
// Test: getDuplicate() soll Fehler erkennen, wenn arr == NULL
// ---------------------------------------------------------------------------
void test_getDuplicate_handles_null_pointer(void)
{
    unsigned int result = getDuplicate(NULL, 10);
// Erwartung: Fehlerzustand → aktuell vermutlich 0 oder UINT_MAX
    // Wir prüfen nur, DASS es ein Fehler ist:
    TEST_ASSERT_TRUE(result == 0 || result == UINT_MAX);
}


// ---------------------------------------------------------------------------
// Test: getDuplicated) soll Fehler erkennen, wenn count < 2
// ---------------------------------------------------------------------------
void test_getDuplicate_handles_invalid_count(void)
{
    unsigned int dummy[1] = { 5 };

    unsigned int result = getDuplicate(dummy, 1);

    TEST_ASSERT_TRUE(result == 0 || result == UINT_MAX);
}

// ---------------------------------------------------------------------------
// main() für Unity
// ---------------------------------------------------------------------------
int main(void)
{
    UNITY_BEGIN();

    RUN_TEST(test_createNumbers_returns_valid_array);
    RUN_TEST(test_createNumbers_contains_exactly_one_duplicate);
    RUN_TEST(test_getDuplicated_finds_correct_duplicate);
    RUN_TEST(test_createNumbers_rejects_too_small_counts);
    RUN_TEST(test_createNumbers_with_two_elements_is_valid);
    RUN_TEST(test_getDuplicate_handles_null_pointer);
    RUN_TEST(test_getDuplicate_handles_invalid_count);

    return UNITY_END();
}