#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. */

// Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries.
// Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
// creating random numbers.
// Returns len random numbers between 1 and 2*len in random order,
// all different, except for exactly one duplicate (two entries the same).
// Uses your binary search tree implementation to check for duplicates while generating numbers.
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "numbers.h"
#include "bintree.h"

int compareFct(const void *a, const void *b)
  {
      return (*(int *)a > *(int *)b) - (*(int *)a < *(int *)b); // a und b werden in int konvertiert und deren Werte miteinander verglichen
                                                                // returns 1 for a>b or -1 for a<b
                                                                // in bintree.c wird ueberprueft, ob compare eine positive oder eine negative Zahl zurueckgibt,
                                                                // wenn a groeßer b, positiv und dann wird links nach Teilbauemen gesucht
  }

// Erzeugt len Zufallszahlen zwischen 1 und 2*len
// alle einzigartig, außer genau ein Duplikat
unsigned int *createNumbers(unsigned int len)
{
    if (len < 2)
        return NULL;

    srand((unsigned int)time(NULL));

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

    TreeNode *root = NULL; // Baum anfänglich leer
    unsigned int count = 0;

    // Zufallszahlen generieren, bis das Array voll ist
    while (count < len)
    {
        unsigned int random = (rand() % (2 * len)) + 1;
        int duplicate = 0; // Anfangswert für Duplikat-Check

        root = addToTree(root, &random, sizeof(random), compareFct, &duplicate);

        if (root == NULL)
        {
            free(numbers);
            return NULL;
        }

        if (!duplicate)
        {
            numbers[count++] = random;
        }
        // duplicate == 1 → Zahl existiert schon, neue Zahl generieren
    }

    // genau ein Duplikat erzeugen
    unsigned int idx1 = rand() % len;
    unsigned int idx2 = rand() % len;
    while (idx2 == idx1)
        idx2 = rand() % len;

    numbers[idx2] = numbers[idx1];

    // Baum wieder freigeben
    clearTree(root);

    return numbers;
}


// findet die eine doppelte Zahl im Array
unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
{
    if (!numbers || len < 2)
        return 0;

    for (unsigned int i = 0; i < len; i++)
    {
        for (unsigned int j = i + 1; j < len; j++)
        {
            if (numbers[i] == numbers[j])
                return numbers[i];
        }
    }

    return 0;
}