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

void creat_array(int *arr, case_t c, result_t *buf,int n){

	int i, size;
	size = buf[n].size;

	//printf("%d\n", size);

	if(c == best_t)
	{
		for(i=0;i<size;i++){
			*arr=i;
			arr++;
		}
	}
	if(c == worst_t)
	{
		for(i=0;i<size;i++){
			*arr=size-i;
			arr++;
		}
	}
	if(c == average_t)
	{
		for(i=0;i<size;i++){
			if(i<(size/2))
			{
				*arr= i;
				arr++;
			}
			if(i>(size/2))
			{
				*arr=size-i;
				arr++;
			}
		}
	}

}

void benchmark(const algorithm_t a, const case_t c, result_t *buf, int n)
{
	struct timespec start, stop;
	long s, ns;
    int i, g, j, x, search, b=1000000000;
    int *array;
    buf[0].size = SIZE_START;
    x=1;

    //Sätter alla storlekar till rätt värdet i buf.size
    for(g=0;g<n;g++){
        if(x<n){
			buf[x].size = buf[g].size*2;
		}
        x++;
	}
    for(g=0;g<(n*n*n);g++)
    {
		search = rand() % buf[g%n].size;
        /*if(c == best_t)
        {
            for(i=0;i<buf[g%n].size;i++)
            {
                array[i] = i;
                // printf("%d    ", array[i]);
            }
        }

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

        else if(c == average_t)
        {
        //  srand(time(NULL));
            for(i=0;i<buf[g%n].size;i++)
            {
                array[i] = rand() % buf[g%n].size;
            //  printf("%d    ", array[i]);

            }
        }*/

		array = (int*)malloc(buf[g%n].size*sizeof(int));
        creat_array(array, c, buf, (g%n));

        if(a == bubble_sort_t)
        {
            clock_gettime(CLOCK_MONOTONIC, &start);
            bubble_sort(array, buf[g%n].size);
        }

        else if(a == quick_sort_t)
        {
            clock_gettime(CLOCK_MONOTONIC, &start);
            quick_sort(array, buf[g%n].size);
        }

        else if(a == insertion_sort_t)
        {
            clock_gettime(CLOCK_MONOTONIC, &start);
            insertion_sort(array, buf[g%n].size);
        }

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

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

        else if(a == linear_search_t && c == average_t)
        {
            clock_gettime(CLOCK_MONOTONIC, &start);
            linear_search(array, buf[g%n].size, search);
        }

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

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

        else if(a == binary_search_t && c == average_t)
        {
            quick_sort(array, buf[g%n].size);
            clock_gettime(CLOCK_MONOTONIC, &start);
            binary_search(array, buf[g%n].size, search);

         }
        clock_gettime(CLOCK_MONOTONIC, &stop);
        s = stop.tv_sec - start.tv_sec;
        ns = stop.tv_nsec - start.tv_nsec;
        if(start.tv_nsec > stop.tv_nsec) { // clock underflow
			--s;
			ns += b;
    	}

        buf[g%n].time += ((double)s + (double)ns) / (double)b;
        free(array);
    }
	for(g=0;g<n;g++){
		buf[g].time = (buf[g].time / (n*n));
	}

}