#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.
// Vergleichsfunktion für qsort
static int compareUnsignedInt(const void *a, const void *b)
{
const unsigned int *x = (const unsigned int *)a;
   const unsigned int *y = (const unsigned int *)b;

   if (*x < *y) return -1;
   if (*x > *y) return 1;
   return 0;
}

// Fisher-Yates Shuffle Algorithmus zum Mischen des Arrays
static void shuffleArray(unsigned int *array, unsigned int n)
{
   if (n > 1)
   {
       for (unsigned int i = n - 1; i > 0; i--)
       {
           unsigned int j = rand() % (i + 1);
           unsigned int temp = array[i];
           array[i] = array[j];
           array[j] = temp;
       }
   }
}

unsigned int *createNumbers(unsigned int len)
{
   if (len < 2) return NULL;

   // 1. Array reservieren
   unsigned int *numbers = malloc(len * sizeof(unsigned int));
   if (numbers == NULL) return NULL;

   // Hilfsvariablen für den Baum
   TreeNode *root = NULL;
   int isDuplicate = 0;
   unsigned int count = 0;

   // 2. PHASE 1: Erzeuge (len - 1) EINZIGARTIGE Zahlen mit Hilfe des Baums
   // Wir nutzen den Baum als "Türsteher"
   while (count < len - 1)
   {
       // Zufallszahl generieren (1 bis 2*len)
       unsigned int value = (rand() % (2 * len)) + 1;

       // Versuchen, in den Baum einzufügen
       // Wir übergeben &isDuplicate, damit der Baum Duplikate ABLEHNT.
       root = addToTree(root, &value, sizeof(unsigned int), compareUnsignedInt, &isDuplicate);

       // Prüfen: War es ein Duplikat?
       if (isDuplicate == 0)
       {
           // Nein, es war neu! -> Ins Array schreiben
           numbers[count] = value;
           count++;
       }
       // Falls isDuplicate == 1, machen wir einfach weiter (while-Schleife läuft weiter)
   }

   // 3. PHASE 2: Das garantierte Duplikat erzeugen
   // Wir wählen zufällig eine der bereits existierenden Zahlen aus
   unsigned int randomIndex = rand() % (len - 1);
   unsigned int duplicateValue = numbers[randomIndex];

   // Wir schreiben das Duplikat an die allerletzte Stelle
   numbers[len - 1] = duplicateValue;

   // Optional: Duplikat auch in den Baum einfügen (Modus: Akzeptieren / isDuplicate = NULL)
   // Damit der Baum konsistent zum Array ist (falls man ihn später noch braucht).
   root = addToTree(root, &duplicateValue, sizeof(unsigned int), compareUnsignedInt, NULL);

   // 4. Mischen
   // Da das Duplikat jetzt immer ganz am Ende steht, müssen wir mischen.
   shuffleArray(numbers, len);

   // 5. Aufräumen
   // Der Baum war nur ein Hilfsmittel zur Überprüfung. Er wird jetzt gelöscht.
   // WICHTIG: Damit verhindern wir Memory Leaks [cite: 12]
   clearTree(root);

   return numbers;
}

// ... Hierunter bleibt die getDuplicate Funktion deines Kollegen unverändert ...
// Sie ist korrekt implementiert laut Aufgabenstellung (mit qsort)[cite: 11, 43].
unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
{
 if (numbers == NULL || len < 2) {
   return 0;
 }

 unsigned int *copy = malloc(len * sizeof(unsigned int));
 if (copy == NULL) {
   return 0;
 }

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

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

 unsigned int duplicate = 0;

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

 free(copy);
 return duplicate;
}