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

int compareUnsignedInt(const void *a, const void *b) {
  unsigned int x = *(unsigned int *)a;
  unsigned int y = *(unsigned int *)b;

  if (x < y)
    return -1;
  if (x > y)
    return 1;
  return 0;
}

// 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) {
  if (len < 2)
    return NULL;

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

  TreeNode *root = NULL;
  srand((unsigned int)time(NULL));

  for (unsigned int i = 0; i < len - 1; i++) {
    unsigned int num;
    int isDuplicate;

    do {
      num = (rand() % (2 * len)) + 1;
      isDuplicate = 0;

      root = addToTree(root, &num, sizeof(unsigned int), compareUnsignedInt,
                       &isDuplicate);

    } while (isDuplicate); // nur akzeptieren, wenn eindeutig

    arr[i] = num;
  }

  // Jetzt gezielt EIN Duplikat erzeugen
  unsigned int duplicateIndex = rand() % (len - 1);
  arr[len - 1] = arr[duplicateIndex];

  clearTree(root);
  return arr;
}

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

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

  // Sortierung
  qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);

  // Duplikat finden: zwei gleiche nebeneinander
  unsigned int duplicate = 0;
  for (unsigned int i = 0; i < len - 1; i++) {
    if (copy[i] == copy[i + 1]) {
      duplicate = copy[i];
      break;
    }
  }

  free(copy);
  return duplicate;
}