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

//TODO: getDuplicate und createNumbers implementieren
/*  *   * Erzeugen eines Arrays mit der vom Nutzer eingegebenen Anzahl an Zufallszahlen.
  * Sicherstellen, dass beim Befüllen keine Duplikate entstehen.
  * Duplizieren eines zufälligen Eintrags im Array.
  * in `getDuplicate()`: Sortieren des Arrays und Erkennen der doppelten Zahl durch Vergleich benachbarter Elemente. */


// -------------------------------------------------------------
// Vergleichsfunktion für qsort (Aufsteigend sortieren)
// -------------------------------------------------------------
static int compareUnsignedInt(const void *a, const void *b)
{
    const unsigned int *ia = a;
    const unsigned int *ib = b;

    if (*ia < *ib) return -1;
    if (*ia > *ib) return 1;
    return 0;
}



// -------------------------------------------------------------
// createNumbers
// Erzeugt ein Array aus len Zufallszahlen (1..2*len), alle verschieden.
// Danach wird genau EIN zufälliger Eintrag dupliziert.
// Parameter:  len = Anzahl der gewünschten Zufallszahlen
// Rückgabe:   Pointer auf das erzeugte Array 
// -------------------------------------------------------------
unsigned int *createNumbers(unsigned int len)
{
    if (len < 2)
        return NULL;

    srand(time(NULL));

    unsigned int *numbers = malloc(len * sizeof(unsigned int));
    if (!numbers)
        return NULL;

    unsigned int count = 0;

    // alle Werte verschieden erzeugen
    while (count < len)
    {
        unsigned int value = (rand() % (2 * len)) + 1;

        // Duplikatsprüfung 
        int exists = 0;
        for (unsigned int i = 0; i < count; i++) {
            if (numbers[i] == value) {
                exists = 1;
                break;
            }
        }

        if (!exists)
            numbers[count++] = value;
    }

    // EIN Duplikat erzeugen
    unsigned int i1 = rand() % len;
    unsigned int i2 = rand() % len;
    while (i2 == i1)
        i2 = rand() % len;

    numbers[i2] = numbers[i1];

    return numbers;
}



// -------------------------------------------------------------
// getDuplicate
// Findet die einzige Zahl, die im Array zweimal vorkommt.
// Sortiert dazu eine Kopie des Arrays und vergleicht benachbarte Werte.
// Parameter:  numbers = Array von Zufallszahlen
//             len     = Anzahl der Elemente
// Rückgabe:   die doppelte Zahl oder 0 bei Fehler
// -------------------------------------------------------------
unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
{
    if (!numbers || len < 2)
        return 0;

    // Kopie erzeugen, damit das Original unverändert bleibt
    unsigned int *copy = malloc(len * sizeof(unsigned int));
    if (!copy)
        return 0;

    memcpy(copy, numbers, len * sizeof(unsigned int));

    // Sortieren
    qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);

    // benachbarte Elemente vergleichen
    unsigned int duplicate = 0;
    for (unsigned int i = 1; i < len; i++) {
        if (copy[i] == copy[i - 1]) {
            duplicate = copy[i];
            break;
        }
    }

    free(copy);
    return duplicate;
}