#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.
// Returns len random numbers between 1 and 2*len in random order,
// all different, except for exactly one duplicate (two entries the same).
// Uses your binary search tree implementation to check for duplicates while generating numbers.
unsigned int *createNumbers(unsigned int len)
{
  if (len < 2)
    return NULL;

  srand(time(NULL));


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

  TreeNode *root = NULL; // Baum anfänglich leer
  unsigned int count = 0;

  // Zufallszahlen generieren, bis das Array voll ist
  while (count < len) {
    unsigned int random = (rand() % (2 * len)) + 1;

    int duplicate = 0; // Anfangswert für Duplikat-Check
    root = addToTree(root, &random, sizeof(random), compareFct, &duplicate);

    if (root == NULL) {
      free(numbers);
      return NULL;
    }

    if (!duplicate) { // Zahl war neu → ins Array einfügen
      numbers[count++] = random;
    }
    // duplicate == 1 → Zahl existiert schon, neue Zahl generieren
  }

  // Jetzt len eindeutige Zahlen erzeugt → ein Duplikat erzwingen
  unsigned int idx1 = rand() % len;
  unsigned int idx2 = rand() % len;
  while (idx2 == idx1)                // sicherstellen, dass es eine andere Position ist
    idx2 = rand() % len;

  numbers[idx2] = numbers[idx1];

  // Baum wieder freigeben
  clearTree(root);

  return numbers;
}

  // Jetzt len eindeutige Zahlen erzeugt ⇒ wir müssen ein Duplikat erzwingen
  unsigned int idx1 = rand() % len;
  unsigned int idx2 = rand() % len;
  while (idx2 == idx1)
    idx2 = rand() % len;

  numbers[idx2] = numbers[idx1];   // zweites Exemplar

  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(len>0)
    {
    unsigned int duplicate = 0;
    for(unsigned int i=0;i<len;i++)
      {
        unsigned int v1 = numbers[i];
        for(unsigned int j=i+1;j<len;j++)
          {
          unsigned int v2 = numbers[j];
          if(v1==v2)
            {
            return v1;
            }
          }
      }
    }
  return 0;
}