#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.
void duplicateNumber(unsigned int *numbers, unsigned int len)
{
  if (!numbers || len < 2)
    return;

  unsigned int numberPicked = rand() % len; // take random spot in array
  unsigned int destination = rand() % len;  // new spot for duplicated number

  while (destination == numberPicked) // while same spot get a new one
    destination = rand() % len;

  numbers[destination] = numbers[numberPicked];
}

/* for qsort
-1	  num1 should come before num2
0	    num1 and num2 are equal
1	    num1 should come after num2
*/
int compare(const void *num1, const void *num2)
{
  unsigned int temp1 = *(const unsigned int *)num1;
  unsigned int temp2 = *(const unsigned int *)num2;
  return (temp1 > temp2) - (temp1 < temp2);
}

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

  TreeNode *root = NULL;
  unsigned int i = 0;

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

  while (i < len)
  {
    unsigned int random = (rand() % (2 * len)) + 1;
    int duplicate = 0;

    root = addToTree(root, &random, sizeof(unsigned int), compare, &duplicate);
    if (!root)
    {
      free(numbers); // malloc-Fehler
      return NULL;
    }

    if (!duplicate)
      numbers[i++] = random;
  }

  duplicateNumber(numbers, len);
  clearTree(root);
  return numbers;
}

// Returns 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 || len < 2)
  {
    return 0;
  }

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

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

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

  free(copy);
  return duplicate;
}