#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. */
static int compareUnsignedInt(const void *arg1, const void *arg2)
{
  unsigned int val1 = *(const unsigned int *)arg1;
  unsigned int val2 = *(const unsigned int *)arg2;

  if (val1 < val2)
    return -1;
  else if (val1 > val2)
    return 1;
  else
    return 0;
}
// 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.
unsigned int *createNumbers(unsigned int len)
{
  if (len < 1)
    return NULL;

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


  // Binärbaum für Duplikaterkennung
  TreeNode *tree = NULL;

  // len verschiedene Zufallszahlen erzeugen (zwischen 1 und 2*len)
  for (unsigned int i = 0; i < len; i++)
  {
    unsigned int randomNum;
    int isDuplicate;

    // Wiederhole, bis eine neue (nicht-doppelte) Zahl gefunden wird
    do
    {
      isDuplicate = 0;
      randomNum = (rand() % (2 * len)) + 1;  // Zahlen zwischen 1 und 2*len

      // Versuche in Baum einzufügen und prüfe auf Duplikat
      tree = addToTree(tree, &randomNum, sizeof(unsigned int), compareUnsignedInt, &isDuplicate);
    } while (isDuplicate == 1);

    numbers[i] = randomNum;
  }

  // Baum freigeben
  clearTree(tree);

  // Zufälligen Index wählen und diesen Wert duplizieren
  unsigned int duplicateIndex = rand() % len;
  unsigned int duplicateValue = numbers[duplicateIndex];

  // Einen anderen zufälligen Index finden, um das Duplikat einzufügen
  unsigned int targetIndex;
  do
  {
    targetIndex = rand() % len;
  } while (targetIndex == duplicateIndex);

  // Duplikat einfügen
  numbers[targetIndex] = duplicateValue;

  return numbers;
}

// Returns only the only number in numbers which is present twice. Returns zero on errors.
unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
{
  if (numbers == NULL || len < 2)
    return 0;

  // Kopie des Arrays erstellen (da qsort das Original verändert)
  unsigned int *sortedNumbers = (unsigned int *)malloc(len * sizeof(unsigned int));
  if (sortedNumbers == NULL)
    return 0;

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

  // Array sortieren
  qsort(sortedNumbers, len, sizeof(unsigned int), compareUnsignedInt);

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

  // Speicher freigeben
  free(sortedNumbers);

  return duplicate;
}