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

static void duplicateRandomEntry(unsigned int *numbers, unsigned int len)
{
    if (!numbers || len < 2)
        return;

    unsigned int src = rand() % len;
    unsigned int dst = rand() % len;

    while (dst == src)
        dst = rand() % len;

    numbers[dst] = numbers[src];
}


static int compare(const void *a, const void *b)
{
    unsigned int x = *(const unsigned int *)a;
    unsigned int y = *(const unsigned int *)b;
    return (x > y) - (x < y);
}




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

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

    static int seeded = 0;
    if (!seeded) {
        srand((unsigned)time(NULL));
        seeded = 1;
    }

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

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

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

        if (!isDup)
            numbers[i++] = val;
    }

    duplicateRandomEntry(numbers, len);
    clearTree(root);
    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 || 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 dup = 0;
  for (unsigned int i = 1; i < len; i++)
  {
    if (copy[i] == copy[i - 1])
    {
      dup = copy[i];
      break;
    }
  }

  free(copy);
  return dup;
}