#include <stdio.h>
#include <string.h>
#include <CL/cl.h>

int main() {
  cl_int ret;

  cl_uint num_platforms;
  cl_platform_id *platforms;
  cl_platform_id pocl_platform = NULL;
  unsigned i;
  cl_uint num_devices;
  cl_device_id device;
  cl_context context;
  const char* src = "kernel void test(global float *out) { *out = M_PI_F; }";
  size_t src_len = strlen(src) + 1;
  cl_program program;
  cl_kernel kernel;
  float out;
  cl_mem buffer;
  cl_command_queue queue;
  size_t global_work_size = 1;

  ret = clGetPlatformIDs(0, NULL, &num_platforms);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  platforms = malloc(num_platforms * sizeof(cl_platform_id));
  if (!platforms)
    return EXIT_FAILURE;

  ret = clGetPlatformIDs(num_platforms, platforms, NULL);

  for (i = 0; i < num_platforms; i++) {
    char *platform_name;
    char *platform_vendor;
    size_t param_size;
    cl_platform_id platform = platforms[i];

    /* Get platform name */
    ret = clGetPlatformInfo(platform, CL_PLATFORM_NAME, 0, NULL, &param_size);
    if (ret != CL_SUCCESS)
      return EXIT_FAILURE;

    platform_name = malloc(param_size);
    if (!platform_name)
      return EXIT_FAILURE;

    ret = clGetPlatformInfo(platform, CL_PLATFORM_NAME, param_size,
          platform_name, NULL);

    if (ret != CL_SUCCESS)
      return EXIT_FAILURE;

    if (!strcmp(platform_name, "Portable Computing Language")) {
      pocl_platform = platform;
      free(platform_name);
      break;
    }

    free(platform_name);
  }

  if (!pocl_platform)
    return EXIT_FAILURE;

  ret = clGetDeviceIDs(pocl_platform, CL_DEVICE_TYPE_CPU, 0, NULL,
                       &num_devices);
  if (ret != CL_SUCCESS || num_devices < 1)
    return EXIT_FAILURE;

  ret = clGetDeviceIDs(pocl_platform, CL_DEVICE_TYPE_CPU, 1, &device, NULL);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  context = clCreateContext(NULL, 1, &device, NULL, NULL, &ret);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  program = clCreateProgramWithSource(context, 1, &src, &src_len, &ret);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  ret = clBuildProgram(program, 1, &device, NULL, NULL, NULL);
  if (ret != CL_SUCCESS) {
    size_t param_size;
    char *log;
    ret = clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0, NULL,
                                &param_size);
    if (ret != CL_SUCCESS)
      return EXIT_FAILURE;

    log = malloc(param_size);
    ret = clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, param_size,
                                log, NULL);
    if (ret != CL_SUCCESS)
      return EXIT_FAILURE;
    
    fprintf(stderr, "%s\n", log);
    return EXIT_FAILURE;
  }

  kernel = clCreateKernel(program, "test", &ret);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  buffer = clCreateBuffer(context, CL_MEM_USE_HOST_PTR, sizeof(out), &out, &ret);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  ret = clSetKernelArg(kernel, 0, sizeof(buffer), &buffer);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  queue = clCreateCommandQueue(context, device, 0, &ret);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  ret = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &global_work_size, NULL,
                               0, NULL, NULL);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  ret = clFinish(queue);
  if (ret != CL_SUCCESS)
    return EXIT_FAILURE;

  printf("pi = %f\n", out);
  if (out != CL_M_PI_F)
    return EXIT_FAILURE;

  return EXIT_SUCCESS;
}