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

static int compareInt(const void *ptr1, const void *ptr2);

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

/*
the implemented tree can't efficiently check if it contains a specific number, but we don't actually need that anyways
create numbers just counts and checks if the just inserted number sets the isDuplicate pointer
*/
// srand should have been called before this function
unsigned int *createNumbers(unsigned int len)
{
  unsigned int *randomNumbers = malloc(len * sizeof(int));

  // including upper limit
  int upperLimit = len * 2;

  int numberCnt = 0;

  int isDuplicate = 0;
  TreeNode *root = NULL;
  // we only need len-1 numbers because 1 will be duplicated
  while (numberCnt < len - 1)
  {
    // numbers up to and including upperLimit without 0
    int randNum = rand() % upperLimit + 1;
    // reset isDuplicate
    isDuplicate = 0;
    // don't forget to set the root here
    root = addToTree(root, &randNum, sizeof(randNum), (CompareFctType)compareInt, &isDuplicate);
    if (isDuplicate)
    {
      // number already exists
      continue;
    }
    randomNumbers[numberCnt++] = randNum;
  }

  // select which number to duplicate
  int dupNum = randomNumbers[rand() % numberCnt];
  // ...and where to insert
  int dupNumIdx = rand() % len;

  // move the number currently at the dupNumIdx to the end
  // and insert the dupNum at the index
  // this also works if the last idx was selected for dupNum
  randomNumbers[len - 1] = randomNumbers[dupNumIdx];
  randomNumbers[dupNumIdx] = dupNum;

  // clean up memory
  clearTree(root);
  return randomNumbers;
}

// 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)
{
  qsort((void *)numbers, len, sizeof(int), compareInt); // sort the array
  for (int i = 0; i < len - 1; i++)
  {
    if (numbers[i] == numbers[i + 1])
      return numbers[i];
  }
  return 0; // zero on errors
}

static int compareInt(const void *ptr1, const void *ptr2)
{
  int num1 = *(int *)ptr1;
  int num2 = *(int *)ptr2;
  return num1 - num2;
}