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

/*
// ohne Binärbaum
unsigned int *createNumbers(unsigned int len)
{
  if (len <= 2)
    return NULL;

  // Zufallszahlen erzeugen
  srand(time(NULL));
  unsigned int *numbers = malloc(len * sizeof(unsigned int));
  // prüfen, ob Speicher richtig reserviert wurde
  if (numbers == NULL)
  {
    printf("Es konnte nicht genügend Speicher reserviert werden");
    free(numbers);
    return NULL;
  }
  // einsetzen der Zahlen ins array
  for (size_t i = 0; i < len; i++)
  {
    numbers[i] = rand() % ((2 * len) + 1);
    // stellt sicher, dass keine Duplikate vorhanden sind
    for (size_t j = 0; j < i; j++)
    {
      if (numbers[i] == numbers[j])
      {
        i--;
        break;
      }
    }
  }
  // numbers[rand()% (len+1)] = rand()% ((2* len) + 1);
  size_t dupIndex = rand() % len;    // Index, der dupliziert wird
  size_t targetIndex = rand() % len; // Ziel-Index, wo das Duplikat hin soll
  if (dupIndex != targetIndex)
  {
    numbers[targetIndex] = numbers[dupIndex]; // echtes Duplikat
  }
  return numbers;
  free(numbers);
}

int compare(const void *a, const void *b)
{
  return (*(int *)a - *(int *)b);
}
*/
// mit Binärbaum

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

  // Zufallszahlen erzeugen
  srand(time(NULL));
  unsigned int *numbers = malloc(len * sizeof(unsigned int));
  // prüfen, ob Speicher richtig reserviert wurde
  if (numbers == NULL)
  {
    printf("Es konnte nicht genügend Speicher reserviert werden");
    free(numbers);
    return NULL;
  }

  TreeNode *root = NULL;
  for (size_t i = 0; i < len; i++)
  {
    unsigned int isDup = 0;
    numbers[i] = (rand() % (2 * len)) + 1;
    root = addToTree(root, &numbers, sizeof(numbers), compare, &isDup);
    if (isDup != 1)
    {
      i--;
    }
  }

  // numbers[rand()% len] = (rand()% (2* len) + 1);
  size_t dupIndex = rand() % len;    // Index, der dupliziert wird
  size_t targetIndex = rand() % len; // Ziel-Index, wo das Duplikat hin soll
  if (dupIndex != targetIndex)
  {
    numbers[targetIndex] = numbers[dupIndex]; // echtes Duplikat
  }
  return numbers;
  clearTree(root);
  free(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)
{
  unsigned int dobble;
  // neues Array zum reinkopieren initialisieren
  unsigned int *nums = malloc(len * sizeof(unsigned int));
  for (int l = 0; l < len; l++)
    nums[l] = numbers[l];

  // array sortieren
  qsort(nums, len, sizeof(unsigned int), compare);
  for (int k = 0; k < len; k++)
  {
    if (nums[k] == nums[k + 1])
    {
      dobble = nums[k];
      break;
    }
  }
  return dobble;
  free(nums);
}