/*

    ......... 2015 Ivan Mahonin

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <cassert>

#include <iostream>

#include <fstream>

#include "clcontext.h"

using namespace std;

ClContext::ClContext():

	err(),

	device(),

	context(),

	queue(),

	max_compute_units(),

	max_group_size()

{

	const int platform_index = 0;

	const int device_index = 0;

	// platform

	cl_uint platform_count = 0;

	err |= clGetPlatformIDs(0, NULL, &platform_count);

	assert(!err);

	//cout << platform_count << " platforms" << endl;

	vector<cl_platform_id> platforms(platform_count);

	err |= clGetPlatformIDs(platforms.size(), &platforms.front(), NULL);

	assert(!err);

	assert(platform_index < (int)platform_count);

	cl_platform_id platform = platforms[platform_index];

	char vendor[256] = { };

	err |= clGetPlatformInfo(platform, CL_PLATFORM_VENDOR, sizeof(vendor), vendor, NULL);

	assert(!err);

	//cout << "Use CL platform " << platform_index << " by " << vendor << endl;

    char platform_version[256];

    err |= clGetPlatformInfo(platform, CL_PLATFORM_VERSION, sizeof(platform_version), platform_version, NULL);

	assert(!err);

	//cout << "Platform " << platform_index << " OpenCL version " << platform_version << endl;

	// devices

	cl_uint device_count = 0;

    err |= clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, 0, NULL, &device_count);

    assert(!err);

    //cout << device_count << " devices" << endl;

	vector<cl_device_id> devices(device_count);

    err |= clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, devices.size(), &devices.front(), NULL);

    assert(!err);

	assert(device_index < (int)device_count);

    device = devices[device_index];

    char device_name[256];

    err |= clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(device_name), device_name, NULL);

    assert(!err);

    //cout << "Device " << device_index << " name " << device_name << endl;

    char device_version[256];

    err |= clGetDeviceInfo(device, CL_DEVICE_VERSION, sizeof(device_version), device_version, NULL);

    assert(!err);

    //cout << "Device " << device_index << " OpenCL version " << device_version << endl;

    err |= clGetDeviceInfo(device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(max_compute_units), &max_compute_units, NULL);

    assert(!err);

    //cout << "Device " << device_index << " max compute units " << max_compute_units << endl;

    unsigned int max_dimensions;

    err |= clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(max_dimensions), &max_dimensions, NULL);

    assert(!err);

    assert(max_dimensions);

    //cout << "Device " << device_index << " max work dimensions " << max_dimensions << endl;

    vector<size_t> max_group_sizes(max_dimensions);

    err |= clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_GROUP_SIZE, max_group_sizes.size()*sizeof(size_t), &max_group_sizes.front(), NULL);

    assert(!err);

    max_group_size = max_group_sizes.front();

    //cout << "Device " << device_index << " max group size " << max_group_size << endl;

	size_t timer_resolution;

    err |= clGetDeviceInfo(device, CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof(timer_resolution), &timer_resolution, NULL);

    assert(!err);

    //cout << "Device " << device_index << " timer resolution " << timer_resolution << " ns" << endl;

    unsigned long long global_mem_size;

    err |= clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(global_mem_size), &global_mem_size, NULL);

    assert(!err);

    //cout << "Device " << device_index << " global mem size " << global_mem_size << endl;

    unsigned long long local_mem_size;

    err |= clGetDeviceInfo(device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(local_mem_size), &local_mem_size, NULL);

    assert(!err);

    //cout << "Device " << device_index << " local mem size " << local_mem_size << endl;

    unsigned long long max_constant_buffer_size;

    err |= clGetDeviceInfo(device, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(max_constant_buffer_size), &max_constant_buffer_size, NULL);

    assert(!err);

    //cout << "Device " << device_index << " max constant buffer size " << max_constant_buffer_size << endl;

	// context

    cl_context_properties context_props[] = {

    	CL_CONTEXT_PLATFORM,       (cl_context_properties)platform,

		CL_NONE };

    context = clCreateContext(context_props, 1, &device, callback, NULL, &err);

    assert(context);

	// command queue

    cl_command_queue_properties props = 0

    	//| CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE

    	//| CL_QUEUE_PROFILING_ENABLE

    	| 0;

	queue = clCreateCommandQueue(

		context, device, props, NULL);

	assert(queue);

	//hello();

}

ClContext::~ClContext() {

	clReleaseCommandQueue(queue);

	clReleaseContext(context);

}

void ClContext::callback(const char *, const void *, size_t, void *) { }

cl_program ClContext::load_program(const std::string &filename) {

	ifstream f(("cl/" + filename).c_str());

	string text((istreambuf_iterator<char>(f)), istreambuf_iterator<char>());

	const char *text_pointer = text.c_str();

	cl_program program = clCreateProgramWithSource(context, 1, &text_pointer, NULL, NULL);

	assert(program);

	const char options[] = " -Werror ";

	err = clBuildProgram(program, 1, &device, options, NULL, NULL);

	if (err) {

		size_t size;

		clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0, NULL, &size);

		char *log = new char[size];

		clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, size, log, NULL);

		cout << log << endl;

		delete[] log;

	}

	assert(!err);

	return program;

}

void ClContext::hello() {

	// data

	char data[] = "......";

	// buffer

	cl_mem buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR, sizeof(data), data, NULL);

	assert(buffer);

	// program

	cl_program program = load_program("hello.cl");

	// kernel

	cl_kernel kernel = clCreateKernel(program, "hello", NULL);

	assert(kernel);

	err = clSetKernelArg(kernel, 0, sizeof(buffer), &buffer);

	assert(!err);

	size_t work_group_size = sizeof(data);

	cl_event event1 = NULL, event2 = NULL;

	err = clEnqueueNDRangeKernel(

		queue,

		kernel,

		1,

		NULL,

		&work_group_size,

		NULL,

		0,

		NULL,

		&event1 );

	assert(!err);

	// read

	clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, sizeof(data), data, 1, &event1, &event2);

	// wait

	clWaitForEvents(1, &event2);

	cout << data << endl;

	// deinitialize

	clReleaseKernel(kernel);

	clReleaseProgram(program);

	clReleaseMemObject(buffer);

}