#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 checkArray(unsigned int *array, unsigned int len, unsigned int number)
{
  int free = 1;

  for (int i = 0; i < len; i++)
  {
    if (array[i] == number)
    {
      free = 0;
    }
  }

  return free;
}

unsigned int *createNumbers(unsigned int len)
{
  srand(time(NULL));
  unsigned int *array = (unsigned int*)malloc(len * sizeof(unsigned int));
  int randomNr, counter;

  if(array == NULL)
  {
    return NULL;
  }

  for (int i = 0; i < len; i++)
  {
    counter = 0;
    do
    {
      if (counter == 9)
      {
        return NULL;
      }
      
      randomNr = rand() % (2 * len + 1);
      counter++;
    } while (!checkArray(array, i, randomNr));

    array[i] = randomNr;
    printf("%u ", array[i]);
  }

  printf("\n");
  return array;
}

void merge(unsigned int arr[], unsigned int left, unsigned int mid, unsigned int right)
{
  unsigned int i, j, k;
  unsigned int n1 = mid - left + 1;
  unsigned int n2 = right - mid;

  // Create temporary arrays
  unsigned int leftArr[n1], rightArr[n2];

  // Copy data to temporary arrays
  for (i = 0; i < n1; i++)
    leftArr[i] = arr[left + i];
  for (j = 0; j < n2; j++)
    rightArr[j] = arr[mid + 1 + j];

  // Merge the temporary arrays back into arr[left..right]
  i = 0;
  j = 0;
  k = left;
  while (i < n1 && j < n2)
  {
    if (leftArr[i] <= rightArr[j])
    {
      arr[k] = leftArr[i];
      i++;
    }
    else
    {
      arr[k] = rightArr[j];
      j++;
    }
    k++;
  }

  // Copy the remaining elements of leftArr[], if any
  while (i < n1)
  {
    arr[k] = leftArr[i];
    i++;
    k++;
  }

  // Copy the remaining elements of rightArr[], if any
  while (j < n2)
  {
    arr[k] = rightArr[j];
    j++;
    k++;
  }
}

void mergeSort(unsigned int arr[], unsigned int left, unsigned int right)
{
  if (left < right)
  {

    // Calculate the midpoint
    unsigned int mid = left + (right - left) / 2;

    // Sort first and second halves
    mergeSort(arr, left, mid);
    mergeSort(arr, mid + 1, right);

    // Merge the sorted halves
    merge(arr, left, mid, right);
  }
}

// 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 temp[len];
  unsigned int duplicate = 0;

  /*if(numbers == NULL || (sizeof(numbers) / sizeof(typeof(numbers)) != len))
  {
    return 0;S
  }*/

  for (int i = 0; i < len; i++)
  {
    temp[i] = numbers[i];
  }
  
  // Sorting arr using mergesort
  mergeSort(temp, 0, len - 1);

  for (int i = 0; i < len - 1; i++)
  {
    duplicate = temp[i];
    if (duplicate == temp[i + 1])
    {
      
      break;
    }
  }

  return duplicate;
}