#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <OpenCL/opencl.h>
#include <oclUtils.h>


#define MEM_SIZE (128)

int main(int args, char *argv[]) 
{

    int fd = -1;
    const char *filename =  "./hello.cl";
    if ((fd=open(filename,O_RDONLY,0666))==0) {
        fprintf(stderr,"can't open %s\n",filename);
    }

    struct stat sb;
    if (fstat(fd,&sb)) {
        fprintf(stderr,"can't fstat %s\n",filename);
    }

    size_t source_size = sb.st_size;
    void *source_str = malloc(source_size);

    int err = read(fd, source_str, source_size);
    if (err == -1) {
        fprintf(stderr,"can't read %s\n",filename);
    }

    close(fd);

    cl_platform_id platform_id = NULL;
    cl_device_id device_id = NULL;
    cl_uint ret_num_platforms = NULL;
    cl_uint ret_num_devices = NULL;

    cl_int ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms);

    // CL_DEVICE_TYPE_CPU, CL_DEVICE_TYPE_GPU, と指定できる
    // CL_DEVICE_TYPE_DEFAULT はどうなるのか
    ret = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_DEFAULT, 
                          1, &device_id, &ret_num_devices);

    oclCheckError(ret, CL_SUCCESS);

    //OpenCLコンテキストの作成
    cl_context context = clCreateContext( NULL, 1, &device_id, NULL, NULL, &ret);

    cl_command_queue command_queue = clCreateCommandQueue(context, device_id, 0, &ret);

    cl_mem memobj = clCreateBuffer(context, CL_MEM_READ_WRITE, 
                                   MEM_SIZE * sizeof(char), NULL, &ret);

    // カーネルプログラムを読み込む
    cl_program program = clCreateProgramWithSource(context, 1, (const char **)&source_str,
                                                   (const size_t *)&source_size, &ret);

    ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);

    oclCheckError(ret, CL_SUCCESS);

    //カーネルプログラムをビルド
    cl_kernel kernel = clCreateKernel(program, "hello", &ret);

    ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&memobj);

    oclCheckError(ret, CL_SUCCESS);

    ret = clEnqueueTask(command_queue, kernel, 0, NULL, NULL);

    oclCheckError(ret, CL_SUCCESS);

    char string[MEM_SIZE];
    ret = clEnqueueReadBuffer(command_queue, memobj, CL_TRUE, 0, 
                              MEM_SIZE * sizeof(char), string, 0, NULL, NULL);

    oclCheckError(ret, CL_SUCCESS);

    puts(string);

    clFlush(command_queue);
    clFinish(command_queue);
    clReleaseKernel(kernel);
    clReleaseProgram(program);
    clReleaseMemObject(memobj);
    clReleaseCommandQueue(command_queue);
    clReleaseContext(context);

    free(source_str);

    return 0;

}