// Robert Kraig
#include <stdlib.h>
#include <time.h>
#include <iostream.h>

void print_arrays(int *array, int array_size);
void selection_sort(int *array, int array_size);
int *generate_rand_array(int rand_array_size);
int *generate_seeded_rand_array(int , int );
int *input_rand_array(int input_arraysize);

int main(int argc, char *argv[]) {
	int array_seed = 0, use_array_size = 20;
	int *new_array_rand, *new_array_srand, *new_array_input;
	int choice = 0;

	do {
    cout << "1. Generate random Array & Sort"
      << endl
      << "2. Generate seeded Array & Sort"
      << endl
      << "3. Input Random Array & Sort"
      << endl
      << "4. Quit Program"
      << endl;
		cin  >> choice;

		switch (choice) {
			case 1:
				new_array_rand = generate_rand_array(use_array_size);
				print_arrays(new_array_rand,use_array_size);
				choice = 0;
				break;
			case 2:
				cout << "Please Enter Seed for Randomly Generated Array : ";
				cin  >> array_seed;
				new_array_srand = generate_seeded_rand_array(use_array_size,array_seed);
				print_arrays(new_array_srand,use_array_size);
				choice = 0;
				break;
			case 3:
				new_array_input = input_rand_array(use_array_size);
				print_arrays(new_array_input, use_array_size);
				choice = 0;
				break;
      case 4:
        break;
			default:
				cout << "you have not entered the correct digit Please do so again" << endl;
				break;
		}
	} while ((choice != 4));

	return 0;
}

void selection_sort(int *array, int elems)
{
	int startScan, minIndex, minValue;

	for (startScan = 0; startScan < (elems - 1); startScan++)
	{
		minIndex = startScan;
		minValue = array[startScan];
		for (int index=startScan +1; index < elems; index++)
		{
			if(array[index] < minValue)
			{
				minValue = array[index];
				minIndex = index;
			}
		}
		array[minIndex] = array[startScan];
		array[startScan] = minValue;
	}
}

void print_arrays(int *print_array, int arraysize = 0)
{
	cout << "--------------Unsorted array--------------" << endl;
	for (int unsort=0; unsort < arraysize; unsort++)
	{
		cout << print_array[unsort] << endl;
	}
	selection_sort(print_array, arraysize);
	cout << "--------------Sorted array--------------" << endl;
	for (int sort=0; sort < arraysize; sort++)
	{
		cout << print_array[sort] << endl;
	}
}

int *generate_rand_array(int rand_array_size = 0)
{
	int *rand_array;

  /* C-style memory allocation: */
  /* rand_array = (int *) malloc(sizeof(int) * rand_array_size); */
  /* C++-style memory allocation: */
  rand_array = new int[rand_array_size];
  for (int i = 0; i < rand_array_size; i++)
		rand_array[i] = rand();

	return rand_array;
}

int *generate_seeded_rand_array(int srand_array_size = 0, int seed = 0)
{
	int *srand_array;

  /* seeding the RNG doesn't return a value */
	srand(seed);

  /* C-style memory allocation: */
  /* srand_array = (int *) malloc(sizeof(int) * srand_array_size); */

  /* C++-style memory allocation: */
  srand_array = new int[srand_array_size];

	for (int i = 0; i < srand_array_size; i++)
		srand_array[i] = rand();

	return srand_array;
}

int *input_rand_array(int input_array_size = 0)
{
	int *input_array;

  /* C-style memory allocation: */
  /* input_array = (int *) malloc(sizeof(int) * input_array_size); */
  
  /* C++-style memory allocation: */
  input_array = new int[input_array_size];
  
	for (int i = 0; i < input_array_size; i++) {
		cout << i+1 << " : ";
		cin  >> input_array[i];
	}

  return input_array;
}