#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.
unsigned int *createNumbers(unsigned int len)
{
  if (len < 2) return NULL;

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

  srand((unsigned int)time(NULL));

  TreeNode *root = NULL;
  unsigned int maxValue = 2 * len;

  unsigned int uniqueCount = len - 1;  // we generate len-1 unique values
  unsigned int i = 0;

  // Fill len - 1 unique values using BST
  while (i < uniqueCount) {
    unsigned int r = (rand() % maxValue) + 1;
    int isDup = 0;

    root = addToTree(root, &r, sizeof(unsigned int), compareUnsigned, &isDup);

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

  // Pick one number already in the list → duplicate it
  unsigned int duplicateIndex = rand() % uniqueCount;
  unsigned int duplicateValue = numbers[duplicateIndex];

  numbers[len - 1] = duplicateValue;

  // Cleanup tree
  clearTree(root);

  // Shuffle array for randomness
  for (unsigned int j = 0; j < len; j++) {
    unsigned int k = rand() % len;
    unsigned int tmp = numbers[j];
    numbers[j] = numbers[k];
    numbers[k] = tmp;
  }

  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;

  // Make a copy because qsort modifies the array
  unsigned int *copy = malloc(len * sizeof(unsigned int));
  if (!copy) return 0;

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

  qsort(copy, len, sizeof(unsigned int), compareUnsigned);

  // Check adjacent elements for equality
  for (unsigned int i = 0; i < len - 1; i++) {
    if (copy[i] == copy[i + 1]) {
      unsigned int result = copy[i];
      free(copy);
      return result;
    }
  }

  free(copy);
  return 0; // no duplicate found (should not happen)
}