#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 von 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;
}

//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;
       }
   }
}
//Wenn weniger als zwei Zahlen
unsigned int *createNumbers(unsigned int len)
{
   if (len < 2) return NULL;

//Dynamisches Array
   unsigned int *numbers = malloc(len * sizeof(unsigned int));
   if (numbers == NULL) return NULL;
//Variabelen für den Binärbaum
   TreeNode *root = NULL;
   int isDuplicate = 0;
   unsigned int count = 0;


   while (count < len - 1)
   {   //Zufallszahlen generieren
       unsigned int value = (rand() % (2 * len)) + 1;


       root = addToTree(root, &value, sizeof(unsigned int), compareUnsignedInt, &isDuplicate);

       if (isDuplicate == 0)
       {   //in array schreiben falls kein Duplikat
           numbers[count] = value;
           count++;
       }

   }
   //Duplikat erzeugen
   unsigned int randomIndex = rand() % (len - 1);
   unsigned int duplicateValue = numbers[randomIndex];
   numbers[len - 1] = duplicateValue;
   root = addToTree(root, &duplicateValue, sizeof(unsigned int), compareUnsignedInt, NULL);
   //Array mischen damit duplikat nicht am Ende immer ist
   shuffleArray(numbers, len);

   clearTree(root);
   return numbers;
}
//get Duplicate
unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
{
 if (numbers == NULL || len < 2) {
   return 0;
 }
//Kopie vom Array anlegen
 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;
//Duplikat finden
 for (unsigned int i = 0; i + 1 < len; ++i) {
   if (copy[i] == copy[i + 1]) {
     duplicate = copy[i];
     break;
   }
 }
//Speicher freigeben
 free(copy);
 return duplicate;
}