#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include "numbers.h"
#include "bintree.h"

int compareFct(const void *arg1, const void *arg2)
{
  const unsigned int *entry1 = arg1;
  const unsigned int *entry2 = arg2;

  int result = *entry2 - *entry1;

  return result;
}

// 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.
unsigned int *createNumbers(unsigned int len)
{
  srand(time(NULL));

  int isDuplicate = 0;
  unsigned int number = rand() % (2 * len) + 1;
  unsigned int *array = malloc(len * sizeof(unsigned int));
  if (array == NULL)
    return NULL;

  TreeNode* numbers = addToTree(NULL, &number, sizeof(unsigned int), compareFct, &isDuplicate);
  array[0] = number;

  for (unsigned int i = 1; i < len; i++)
  {
    number = rand() % (2 * len) + 1;

    numbers = addToTree(numbers, &number, sizeof(unsigned int), compareFct, &isDuplicate);

    if (isDuplicate == 1)
    {
      isDuplicate = 0;
      i--;
    }
    else
    {
      array[i] = number;
    }
  }

  clearTree(numbers);

  unsigned int duplicatePosition1 = rand() % len;
  unsigned int duplicatePosition2 = rand() % len;

  while (duplicatePosition2 == duplicatePosition1)
  {
    duplicatePosition2 = rand() % len;
  }

  array[duplicatePosition2] = array[duplicatePosition1];

  return array;
}

// 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 *copyNumbers = malloc(sizeof(unsigned int) * len);
  if (copyNumbers == NULL)
    return 0;

  unsigned int duplicateValue = 0;
  
  for (unsigned int i = 0; i < len; i++)
  {
    copyNumbers[i] = numbers [i];
  }

  qsort(copyNumbers, len, sizeof(unsigned int), compareFct);

  for (unsigned int i = 0; i < len - 1; i++)
  {
    if (copyNumbers[i] == copyNumbers[i + 1])
    {
       duplicateValue = copyNumbers[i];
       free(copyNumbers);
       return duplicateValue;
    }
  }
  free(copyNumbers);
  return 0;
}