/*
 ******************************************************************************
 * file name  : main.cpp
 * author     : Hung Q. Ngo
 * description: test run all of the following sorting algorithms
 *  - insertion sort
 *  - selection sort
 *  - merge sort
 *  - quick sort
 *  - randomized quick sort
 *  - heap sort
 *  on random, sorted, and inversedly sorted inputs of varying sizes
 *  print the run times out in a csv file to be opened with Excel
 *  I did the graphing from Excel
 ******************************************************************************
 */
#include <iostream>
#include <vector>
#include <cstdlib>  // for rand() and srand()
#include <ctime>    // for time()

#include "search_sort.h"

using namespace std;

void print_vec(vector<int>& vec);

/**
 * -----------------------------------------------------------------------------
 * print a vector of integers, finish with a new line
 * -----------------------------------------------------------------------------
 */
void print_vec(vector<int>& vec) {
    for (int i=0; i<vec.size(); i++) {
        cout << vec[i] << " ";
    }
    cout << endl;
}

/**
 * -----------------------------------------------------------------------------
 * returns a random vector of n elements, each from 0 to n-1
 * not efficient due to vector copying, but should not affect runtime much
 * -----------------------------------------------------------------------------
 */
vector<int> random_vector(size_t n) {
    srand(static_cast<unsigned int>(time(0)));
    vector<int> ret(n);
    for (int i=0; i<n; i++) 
        ret[i] = rand() % n;
    return ret;
}

/**
 * -----------------------------------------------------------------------------
 * returns a descending vector of n elements, from n down to 1
 * -----------------------------------------------------------------------------
 */
vector<int> descending_vector(size_t n) {
    vector<int> ret(n);
    for (int i=0; i<n; i++) ret[i] = n-i-1;
    return ret;
}

/**
 * -----------------------------------------------------------------------------
 * returns a ascending vector of n elements
 * -----------------------------------------------------------------------------
 */
vector<int> ascending_vector(size_t n) {
    vector<int> ret(n);
    for (int i=0; i<n; i++) ret[i] = i;
    return ret;
}

/**
 * -----------------------------------------------------------------------------
 * returns an almost sorted array, only some 10 of the pairs are swapped
 * -----------------------------------------------------------------------------
 */
vector<int> almost_ascending_vector(size_t n) {
    vector<int> ret(n);
    int i, j,k;
    srand(static_cast<unsigned int>(time(0)));
    for (i=0; i<n; i++) ret[i] = i;
    for (i=0; i<10; i++) {
        j = rand() % n; k = rand() % n;
        swap(ret[j], ret[k]);
    }
    return ret;
}


/**
 *
 * -----------------------------------------------------------------------------
 * run a sorting algorithm pointed to by sort_algo
 * the test data is obtained by get_data
 * the different sizes of the test data is stored in input_sizes
 * -----------------------------------------------------------------------------
 */
void test_run(vector<int> input_sizes, void (*sort_algo)(vector<int>&),
              vector<int> (*get_data)(size_t)) 
{
    time_t start,end;
    double dif;
    vector<int> data;
    for(int i=0; i<input_sizes.size(); i++) {
        time(&start);
        data = get_data(input_sizes[i]);
        sort_algo(data);
        time (&end);
        dif = difftime(end,start);
        cout << dif;
        if (i < input_sizes.size()-1) cout << ",";
        else cout << endl;
    }
}

/**
 * -----------------------------------------------------------------------------
 *  I'm a bit lazy here, could use a map to clean the code up
 * -----------------------------------------------------------------------------
 */
void gather_data(vector<int> input_sizes, vector<int> (*fp)(size_t)) {
    cout << "Insertion,"; 
    test_run(input_sizes, insertion_sort, fp);
    cout << "Selection,"; 
    test_run(input_sizes, selection_sort, fp);
    cout << "Merge,"; 
    test_run(input_sizes, merge_sort, fp);
    cout << "Heap,"; 
    test_run(input_sizes, heap_sort, fp);
    cout << "Quicksort,"; 
    test_run(input_sizes, quick_sort, fp);
    cout << "Randomized Quicksort,"; 
    test_run(input_sizes, randomized_quick_sort, fp);
}

/**
 * -----------------------------------------------------------------------------
 * Test those guys and gather some data
 * We have 4 sorting algorithms: Insertion, Selection, Merge, Quick, and RQuick
 * We'll test them with different sizes and different types of input:
 *  n = 1000, 2000, 10000, 20000, 50000, 100000
 *  input already sorted
 *  input inversedly sorted
 *  input randomized
 *  input almost sorted
 * n=200000 gives me segmentation fault
 * -----------------------------------------------------------------------------
 */
int main() {
    // to test a specific sorting algorithm you can do
    /*
    vector<int> vec = random_vector(30);
    cout << "Before: "; print_vec(vec);
    randomized_quick_sort(vec);
    cout << "After: ";  print_vec(vec);
    */

    static int arr[] = {1000,2000,10000,20000,50000,100000};
    vector<int> input_sizes(arr, arr + sizeof(arr)/sizeof(int));

    cout << "Randomized input: " << endl;
    for (int i=0; i<input_sizes.size(); i++) cout << "," << input_sizes[i];
    cout << endl;
    gather_data(input_sizes, random_vector);

    cout << endl;
    cout << "Almost sorted input: " << endl;
    for (int i=0; i<input_sizes.size(); i++) cout << "," << input_sizes[i];
    cout << endl;
    gather_data(input_sizes, almost_ascending_vector);

    cout << endl;
    cout << "Sorted input: " << endl;
    for (int i=0; i<input_sizes.size(); i++) cout << "," << input_sizes[i];
    cout << endl;
    gather_data(input_sizes, ascending_vector);

    cout << endl;
    cout << "Inversedly sorted input: " << endl;
    for (int i=0; i<input_sizes.size(); i++) cout << "," << input_sizes[i];
    cout << endl;
    gather_data(input_sizes, descending_vector);
}