#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <cuda.h>
#include <cutil_inline.h>
#include <cufft.h>
#include <math_constants.h>



__global__ void kernel(unsigned int *image) {
	
	// cálculo do endereço linear do pixel
	// (quantidade de threads por bloco) * (índice do bloco) + (índice da thread)
	unsigned int index = blockDim.x * blockIdx.x + threadIdx.x;
	
	// [calcular e armazenar resultado da binarização]
	if (image[index] < 128) {
		image[index] = 0;
	} else {
		image[index] = 255;
	}

}

__global__ void crossProduct(unsigned int *vector) {
	unsigned int index = blockDim.x * blockIdx.x + threadIdx.x;

	vector[index] = index*2;
}

#define ENTRADA_PGM "..//..//data//mouse.pgm"
#define SAIDA_PGM "..//..//data//saida.pgm"

extern "C" int crossProductCUDAKernel(int argc, char* argv[]) {
	CUT_DEVICE_INIT(argc, argv);
	

	unsigned int rows = 3;
	unsigned int cols = 3;

	unsigned int *h_vector = NULL;
	unsigned int *d_vector = NULL;

	int size = cols*rows*sizeof(unsigned int);

//	h_vector = (unsigned int*)malloc(size);
	h_vector = new unsigned int[size];
	cudaMalloc((void **) &d_vector, size);

	// ... populate
	for (unsigned int i = 0; i < size; ++i) {
		h_vector[i] = i;
	}

	

	cudaMemcpy(d_vector, h_vector, size, cudaMemcpyKind::cudaMemcpyHostToDevice);

	crossProduct<<<cols,rows>>>(d_vector);

	cudaThreadSynchronize();

	cudaMemcpy(h_vector, d_vector, size, cudaMemcpyKind::cudaMemcpyDeviceToHost);
	
	// ... show
	for (unsigned int i = 0; i < size; ++i) {
		printf("%d ", h_vector[i]);
	}

	printf("\n");
	
	free(h_vector);
	cudaFree(d_vector);
	

	return 0;
}

extern "C" int runCUDAKernel(int argc, char* argv[]) {
	
	CUT_DEVICE_INIT(argc, argv);

	unsigned int width;
	unsigned int height;

	unsigned int *h_image = NULL;
	unsigned int *d_image = NULL;

	// carregar imagem do arquivo de entrada
	int success = cutLoadPGMi(ENTRADA_PGM, &h_image, &width, &height);
	
	if(!success){
		printf("Erro ao carregar imagem.\n");
		return -1;
	}

	// [alocar memória que irá armazenar a imagem em gpu]
	
	int size = width*height*sizeof(unsigned int);

	//cudaError_t cudaMalloc(void **devPtr, size_t size);
	cudaMalloc((void **) &d_image, size);

	// [copiar a imagem da cpu para a gpu]
	//cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind);
	cudaMemcpy(d_image, h_image, size, cudaMemcpyKind::cudaMemcpyHostToDevice);

	// chama o kernel
	kernel<<<width, height>>>(d_image);
	
	// espera pelo final da execução
	cudaThreadSynchronize();

	// [copiar a imagem da gpu para a cpu]
	//cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind);
	cudaMemcpy(h_image, d_image, size, cudaMemcpyKind::cudaMemcpyDeviceToHost);

	// salvar imagem resultante no arquivo de saída
	cutSavePGMi(SAIDA_PGM, h_image, width, height);

	// liberar espaço de memória alocado previamente
	// cudaError_t cudaFree(void *devPtr);
	// void cutFree( void* ptr);

	cudaFree(d_image);
	cutFree(h_image);

	return 0;

}