#include "analyze.h"
#include "algorithm.h"

//
// Private
//



//
// Public
//
void benchmark(const algorithm_t a, const case_t c, result_t *buf, int n)
{
    int i, g;
    buf[0].size = SIZE_START;
    int x = 1;

    for(g=0;g<n;g++)
    {
        int *array = malloc((buf[g].size)*sizeof(int));
        if(c == best_t)
        {						// Bästa case:t , då arrayen är sorterad från början


            for(i=0;i<=buf[g].size;i++)
            {
                array[i] = i;
                // printf("%d    ", array[i]);
            }
        }

        else if(c == worst_t)
        {						// Sämsta case:t , då arrayen är sorterad "bakvänt"
            for(i=buf[g].size;i>=0;i--)
            {
                array[i] = i;
            //  printf("%d    ", array[i]);
            }
        }

        else
        {  						// Average case:t , då arrayen är slumpad
            srand(time(NULL));
            for(i=0;i<buf[g].size;i++)
            {
                array[i] = 1 + rand() % buf[g].size;
            //  printf("%d    ", array[i]);

            }
        }

        double time = 0;
        clock_t start, stop;

        if(a == bubble_sort_t)
        {
            start = clock();
            bubble_sort(array, buf[g].size);
        }


        else if(a == quick_sort_t)
        {
            start = clock();
            quick_sort(array, buf[g].size);
        }


        else if(a == insertion_sort_t)
        {
            start = clock();
            insertion_sort(array, buf[g].size);
        }

        else if(a == linear_search_t && c == best_t)
        {
            start = clock();
            linear_search(array, buf[g].size, 0);
        }

        else if(a == linear_search_t && c == worst_t)
        {
            start = clock();
            linear_search(array, buf[g].size, -1);
        }

        else if(a == linear_search_t && c == average_t)
        {										// Gör random värde med avseende på buffsize
            start = clock();
            linear_search(array, buf[g].size, (buf[g].size)/2);
		}

        else if(a == binary_search_t && c == best_t)
        {
            start = clock();
            binary_search(array, buf[g].size, ((buf[g].size))/2);
        }

        else if(a == binary_search_t && c == worst_t)
        {
            start = clock();
            binary_search(array, buf[g].size, -1);
        }

        else			// Average btw
        {										// Likt linear search vet du inte vad du söker efter, gör random med avsende på buff
            start = clock();
            binary_search(array, buf[g].size, buf[g].size/8);
        }

        stop = clock();
        buf[g].time = (double)(stop-start)/(double)CLOCKS_PER_SEC;

        buf[x].size = buf[g].size*2;
        x++;

        free(array);

       /* if(x > n)
        {
            buf[x].size = (0);
            x = 0;
        } */
    }
}