#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<CL/cl.h>
#include <chrono>
#include "OpenCLExcuter.h"
#include "ImgUtil.h"
using namespace std;
void printDevice();
uchar* createDemoData(int line);
uchar* createTemplateData(int line);

int LINE_NUMBER = 10;
int RE = _NUMBER_L2_TOTAL_NUMBER;



#define CHECK_ERRORS(ERR) \
	if(ERR != CL_SUCCESS){ \
		std::cerr << "OpenCL error code" << ERR << "file: " << __FILE__  << "line: " << __LINE__ << ".\nExiting..." << std::endl; \
		exit(1); \
	}
int main1() {
	//printDevice();
	//return 1;
	auto starttime = std::chrono::steady_clock::now();

	cl_int error;
	cl_uint num_of_platforms = 0;
	cl_platform_id platforms;

	cl_device_id devices;

	cl_context context;

	FILE* program_handle;
	size_t program_size;
	char* program_buffer;
	cl_program program;

	size_t log_size;
	char* program_log;

	char kernel_name[] = "createBuffer";
	cl_kernel kernel;

	cl_command_queue queue;
	//»ñȡƽ̨
	error = clGetPlatformIDs(1, &platforms, &num_of_platforms);
	if (error != 0) {
		printf("Get platform failed!");
		return -1;
	}
	//»ñÈ¡É豸
	error = clGetDeviceIDs(platforms, CL_DEVICE_TYPE_GPU, 1, &devices, NULL);
	if (error != 0) {
		printf("Get device failed!");
		return -1;
	}

	std::cout << " »ñÈ¡É豸£º" << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - starttime).count() << std::endl;

	//´´½¨ÉÏÏÂÎÄ
	context = clCreateContext(NULL, 1, &devices, NULL, NULL, &error);
	if (error != 0) {
		printf("Creat context failed!");
		return -1;
	}
	std::cout << " ´´½¨ÉÏÏÂÎÄ£º" << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - starttime).count() << std::endl;
	//´´½¨³ÌÐò£»×¢ÒâÒªÓÃ"rb"
	 fopen_s(&program_handle,"kernel.cl", "rb");
	if (program_handle == NULL) {
		printf("The kernle can not be opened!");
		return -1;
	}
	fseek(program_handle, 0, SEEK_END);
	program_size = ftell(program_handle);
	rewind(program_handle);

	program_buffer = (char*)malloc(program_size + 1);
	program_buffer[program_size] = '\0';
	error = fread(program_buffer, sizeof(char), program_size, program_handle);
	if (error == 0) {
		printf("Read kernel failed!");
		return -1;
	}
	fclose(program_handle);
	program = clCreateProgramWithSource(context, 1, (const char**)&program_buffer,
		&program_size, &error);
	if (error < 0) {
		printf("Couldn't create the program!");
		return -1;
	}
	//±àÒë³ÌÐò
	error = clBuildProgram(program, 1, &devices, NULL, NULL, NULL);
	if (error < 0) {
		//È·¶¨ÈÕÖ¾ÎļþµÄ´óС
		clGetProgramBuildInfo(program, devices, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
		program_log = (char*)malloc(log_size + 1);
		program_log[log_size] = '\0';
		//¶ÁÈ¡ÈÕÖ¾
		clGetProgramBuildInfo(program, devices, CL_PROGRAM_BUILD_LOG,
			log_size + 1, program_log, NULL);
		printf("%s\n", program_log);
		free(program_log);
		return -1;
	}
	free(program_buffer);

	//´´½¨ÃüÁî¶ÓÁÐ
	queue = clCreateCommandQueue(context, devices, CL_QUEUE_PROFILING_ENABLE, &error);
	if (error < 0) {
		printf("Coudn't create the command queue");
		return -1;
	}
	//----------³ÌÐòÕýÎÄ¿ªÊ¼---------

	for (int n = 0;n < 100;n++)
	{

		auto startexectime = std::chrono::steady_clock::now();



		//´´½¨ÄÚºË
		kernel = clCreateKernel(program, "createBuffer", &error);
		if (kernel == NULL) {
			printf("Couldn't create kernel!\n");
			return -1;
		}
		//³õʼ»¯²ÎÊý
		const int size = 70000;
		float result[size];
		float a_in[size];
		float b_in[size];
		for (int i = 0; i < size; i++) {
			a_in[i] = i+n;
			b_in[i] = i * 2.0;
		}
		//´´½¨»º´æ¶ÔÏó
		cl_mem memObject1 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float) * size, a_in, &error);
		if (error < 0) {
			printf("Creat memObject1 failed!\n");
			return -1;
		}
		cl_mem memObject2 = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
			sizeof(float) * size, b_in, &error);
		if (error < 0) {
			printf("Creat memObject2 failed!\n");
			return -1;
		}
		cl_mem memObject3 = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
			sizeof(float) * size, NULL, &error);
		if (error < 0) {
			printf("Creat memObject3 failed!\n");
			return -1;
		}
		//ÉèÖÃÄں˲ÎÊý
		error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObject1);
		error |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObject2);
		error |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObject3);
		if (error != CL_SUCCESS) {
			printf("Error setting kernel arguments!\n");
			return -1;
		}
		//Ö´ÐÐÄÚºË
		size_t globalWorkSize[1] = { size };
		size_t localWorkSize[1] = { 1 };

		const int work_dim = 2;

		error = clEnqueueNDRangeKernel(queue, kernel, work_dim, NULL, globalWorkSize,
			localWorkSize, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			printf("Error queuing kernel for execution!\n");
			return -1;
		}

		//¶ÁÈ¡Ö´Ðнá¹û
		error = clEnqueueReadBuffer(queue, memObject3, CL_TRUE, 0, size * sizeof(float),
			result, 0, NULL, NULL);
		if (error != CL_SUCCESS) {
			printf("Error reading result buffer!\n");
			return -1;
		}
		//ÏÔʾ½á¹û
		for (int i = 0; i < 2; i++) {
			printf("%f ", result[i]);
		}
		
		clReleaseKernel(kernel);
		clReleaseMemObject(memObject1);
		clReleaseMemObject(memObject2);
		clReleaseMemObject(memObject3);


		std::cout << " Ö´ÐнáÊø£º" << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - startexectime).count() << std::endl;
	}

	//-------------³ÌÐòÕýÎĽáÊø



	//ÊÍ·Å×ÊÔ´
	clReleaseDevice(devices);
	clReleaseContext(context);
	clReleaseProgram(program);
	clReleaseCommandQueue(queue);

	std::cout << " ºÄʱ£º" << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - starttime).count() << std::endl;
	return 0;
}


int main3() {
	ImgUtil::init();
	OpenCLExcuter* op = new OpenCLExcuter();
	int dataCount = 100;


	int rows = 8* dataCount;
	int cols = 5 * LINE_NUMBER * RE;
	uchar* b_in = createTemplateData(dataCount);
	uchar* a_in = createDemoData(dataCount);

	//printf("ÊäÈë1: \n");
	for (int r = 0;r < rows;r++) {
		for (int c = 0;c < cols;c++) {
		//	printf("%d ", a_in[r*cols+c]);
		}
	//	printf("\n");
	}

	//printf("ÊäÈë2: \n");
	for (int r = 0;r < rows;r++) {
		for (int c = 0;c < cols;c++) {
		//	printf("%d ", b_in[r * cols + c]);
		}
		//printf("\n");
	}

	/*
	int rows = 10;
	int cols = 10;
	uchar* b_in = (uchar*)malloc(sizeof(uchar*)*400);
	uchar* a_in = (uchar*)malloc(sizeof(uchar*) * 400);
	for (int i = 0;i < 400;i++) {
		b_in[i] = i;
		a_in[i] = i + 1;
	}
	*/

	op->init();
	for (int i = 0;i < 100;i++)
	{
		op->recognition_numbers(a_in, b_in, rows, cols ,_NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, _NUMBER_L2_TOTAL_NUMBER);
	}
	op->destory();

	return 1;
}

uchar* createDemoData(int line) {
	unsigned char* data = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * line) * 5 * LINE_NUMBER * RE);
	int outLineDataCount = 8 * 5 * LINE_NUMBER * RE;
	int inLineDataCount = 5 * LINE_NUMBER * RE;
	for (int l = 0;l < line;l++)
	{
		int outLineCount = outLineDataCount * l;
		for (int re = 0;re < RE;re++) {

	

			for (int n = 0;n < LINE_NUMBER;n++)
			{
				for (int r = 0;r < 8;r++) {
					int intLineCount = inLineDataCount * r;

					for (int c = 0;c < 5;c++) {
						uchar value = ImgUtil::NUMS_LEVEL2[re%10].data.ptr(r)[c];
						int index = outLineCount;
						index += intLineCount;
						int x = re * LINE_NUMBER * 5 + n * 5 + c;
						index += x;
						data[index] = value > 40 ? 1 : 0;
					}
				}
			}
		}
	}
	return data;
}

uchar* createTemplateData(int line) {
	unsigned char* data = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * line) * _NUMBER_L2_WIDTH * LINE_NUMBER * RE);
	int outLineDataCount = _NUMBER_L2_HEIGHT * _NUMBER_L2_WIDTH * LINE_NUMBER * RE;
	int inLineDataCount = _NUMBER_L2_WIDTH * LINE_NUMBER * RE;
	for (int l = 0;l < line;l++)
	{
		int outLineCount = outLineDataCount * l;
		for (int re = 0;re < RE;re++) {
			for (int n = 0;n < LINE_NUMBER;n++)
			{
				for (int r = 0;r < _NUMBER_L2_HEIGHT;r++) {
					int intLineCount = inLineDataCount * r;

					for (int c = 0;c < _NUMBER_L2_WIDTH;c++) {
						uchar value = ImgUtil::NUMS_LEVEL2[n].data.ptr(r)[c];
						int index = outLineCount;
						index += intLineCount;
						int x = re * LINE_NUMBER * _NUMBER_L2_WIDTH + n * _NUMBER_L2_WIDTH + c;
						index += x;
						data[index] = value > 40 ? 1 : 0;
					}
				}
			}
		}
	}
	return data;
}


void printDevice() {

	cl_int err = CL_SUCCESS;

	// 1. »ñÈ¡µ±Ç°É豸ËùÓÐÖ§³ÖOpenCLµÄƽ̨µÄÊýÁ¿
	cl_uint num_of_platforms = 0;
	err = clGetPlatformIDs(0, 0, &num_of_platforms);
	CHECK_ERRORS(err);

	// 2. »ñÈ¡µ±Ç°É豸ËùÓÐÖ§³ÖOpenCLµÄƽ̨µÄÐÅÏ¢
	cl_platform_id* platforms = new cl_platform_id[num_of_platforms];
	err = clGetPlatformIDs(num_of_platforms, platforms, 0);
	CHECK_ERRORS(err);

	cl_char platform_names[10][50];
	// 3. ´òӡƽ̨ÐÅÏ¢
	cout << "ƽ̨ÐÅÏ¢£º\n";
	for (cl_uint i = 0; i < num_of_platforms; i++)
	{
		// »ñȡƽ̨×Ö·û´®µÄ³¤¶È
		size_t platform_name_length = 0;
		err = clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME, 0, 0, &platform_name_length);
		CHECK_ERRORS(err);

		// »ñȡƽ̨×Ö·û´®
		char* platform_name = new char[platform_name_length];
		err = clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME, platform_name_length, platform_name, 0);
		CHECK_ERRORS(err);

		cout << "    [" << i << "] " << platform_name << endl;

		// ±¸·Ýplatform name
		if (i < 10) {
			memset(platform_names[i], 0, 50);
			memcpy(platform_names[i], platform_name, platform_name_length);
		}

		delete[] platform_name;
	}

	// 4. ²éѯ¸÷ƽ̨É豸ÊýÁ¿
	struct {
		cl_device_type type;
		const  char* name;
		cl_uint count;
	}devices[] = {
		{CL_DEVICE_TYPE_GPU, "CL_DEVICE_TYPE_GPU", 0},					// GPU
		{CL_DEVICE_TYPE_CPU, "CL_DEVICE_TYPE_CPU", 0},					// CPU
		{CL_DEVICE_TYPE_ACCELERATOR, "CL_DEVICE_TYPE_ACCELERATOR", 0}	// ¼ÓËÙÆ÷
	};

	// 5. ±éÀú²éѯ¸÷¸öƽ̨ÏÂÓµÓеÄÉ豸ÊýÁ¿
	for (cl_int j = 0; j < num_of_platforms; j++) {
		cl_platform_id platform = platforms[j];
		cout << "\nplatform:" << platform_names[j] << endl;

		// 6. ±éÀú²éѯGPU¡¢CPU¡¢ACCELERATORÉ豸µÄÊýÁ¿
		for (cl_int i = 0; i < (sizeof(devices) / sizeof(devices[0])); i++)
		{
			err = clGetDeviceIDs(platform, devices[i].type, 0, 0, &devices[i].count);
			if (err == CL_DEVICE_NOT_FOUND) {
				devices[i].count = 0;
				err = CL_SUCCESS;
			}
			CHECK_ERRORS(err);

			cout << "\tdevices:" << devices[i].name
				<< "\tcount:" << devices[i].count;

			if (devices[i].count != 0) {
				// 7. ±éÀú²éѯGPU¡¢CPU¡¢ACCELERATOR ËùÓÐÉ豸µÄÐÅÏ¢
				cl_device_id* device = new cl_device_id[devices[i].count];
				err = clGetDeviceIDs(platform, devices[i].type, devices[i].count, device, 0);

				cout << "\t\tdevice name:";
				for (cl_int k = 0; k < devices[i].count; k++)
				{
					// 8. »ñÈ¡ºÍ´òÓ¡¸÷¸öÉ豸µÄname
					size_t length = 0;
					cl_device_id each_device = device[k];
					err = clGetDeviceInfo(each_device, CL_DEVICE_NAME, 0, 0, &length);
					CHECK_ERRORS(err);

					char* value = new char[length];
					err = clGetDeviceInfo(each_device, CL_DEVICE_NAME, length, value, 0);
					CHECK_ERRORS(err);
					cout << value << " ";

					// 9. »ñÈ¡ºÍ´òÓ¡¸÷¸öÉ豸µÄversion
					err = clGetDeviceInfo(each_device, CL_DEVICE_VERSION, 0, 0, &length);
					CHECK_ERRORS(err);

					char* version = new char[length];
					err = clGetDeviceInfo(each_device, CL_DEVICE_VERSION, length, version, 0);
					CHECK_ERRORS(err);
					cout << version << " ";

					delete[] value;
					delete[] version;
				}

				delete[] device;
			}
			cout << endl;
		}
	}

	delete[] platforms;
}