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

//ohne Binärbaum
unsigned int *createNumbers(unsigned int len)
{
  if (len <= 2)
    return NULL;
  
  // Zufallszahlen erzeugen
  srand(time(NULL));
  unsigned int *numbers = malloc(len * sizeof(unsigned int));
  //prüfen, ob Speicher richtig reserviert wurde
  if(numbers == NULL){
    printf("Es konnte nicht genügend Speicher reserviert werden");
    free(numbers);
    return NULL;
  }
  //einsetzen der Zahlen ins array
  for (size_t i = 0; i < len; i++){
    numbers[i] = rand()%((2*len)+1);
    //stellt sicher, dass keine Duplikate vorhanden sind
    for(size_t j = 0; j < i; j++){
      if(numbers[i] == numbers[j]){
        i--;
        break;
      }
    }

  }
  numbers[rand()% (len+1)] = rand()% ((2* len) + 1);
  return numbers;
  free(numbers);
}

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

//mit Binärbaum
/*
unsigned int *createNumbers(unsigned int len)
{
  if (len <= 2)
    return NULL;
  
  // Zufallszahlen erzeugen
  srand(time(NULL));
  unsigned int *numbers = malloc(len * sizeof(unsigned int));
  //prüfen, ob Speicher richtig reserviert wurde
  if(numbers == NULL){
    printf("Es konnte nicht genügend Speicher reserviert werden");
    free(numbers);
    return NULL;
  }

  TreeNode *root = NULL;
  for(size_t i= 0; i < len; i++){
    unsigned int isDup = 0; 
    numbers[i] = (rand()%(2*len))+1;
    root = addToTree(root, &numbers, sizeof(numbers), compare, &isDup);
    if(isDup != 1){
      i--;
    }
  }

  numbers[rand()% len] = (rand()% (2* len) + 1);
  return numbers;
  clearTree(root);
  free(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)
{
  unsigned int dobble;
  // neues Array zum reinkopieren initialisieren 
  unsigned int *nums = malloc(len * sizeof(unsigned int));
  for(int l = 0; l < len; l++)
    nums[l] = numbers[l]; 

  //array sortieren
  qsort(nums, len, sizeof(unsigned int), compare);
  for(int k = 0; k < len; k++){
    if(nums[k] == nums[k+1]){
      dobble = nums[k];
      break;
    }
  }
  return dobble;
  free(nums);
}