#include <iostream>
#include <vector>
#include <cstdlib>

#include <CL/cl.h>

#define INTEL_PLATFORM_ID 1
#define USE_GPU false

void print_referene_count(const std::string& name, const cl_command_queue& queue)
{
    cl_uint count = 0;
    cl_int err;
    err = clGetCommandQueueInfo(
        queue,
        CL_QUEUE_REFERENCE_COUNT,
        sizeof(cl_uint),
        &count,
        NULL
    );
    if (err != CL_SUCCESS)
    {
        std::cout << "Error: " << __LINE__ << std::endl;
        exit(1);
    }
    std::cout << name << " (" << queue << "): " << count << std::endl;
}

int main(int argc, char** argv)
{
    std::vector<cl_platform_id> platforms;
    cl_device_id device_id;
    cl_context context;

    cl_command_queue host_queue;
    cl_command_queue device_queue1;
    cl_command_queue device_queue2;

    cl_int err;

    cl_uint platforms_num = 0;
    err = clGetPlatformIDs(0, NULL, &platforms_num);
    if (err != CL_SUCCESS)
    {
        std::cout << "Error: " << __LINE__ << std::endl;
        return EXIT_FAILURE;
    }

    platforms.resize(platforms_num);
    err = clGetPlatformIDs(platforms_num, &platforms[0], NULL);
    if (err != CL_SUCCESS)
    {
        std::cout << "Error: " << __LINE__ << std::endl;
        return EXIT_FAILURE;
    }

    err = clGetDeviceIDs(
        platforms[INTEL_PLATFORM_ID],
        USE_GPU ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU,
        1, &device_id, NULL
    );
    if (err != CL_SUCCESS)
    {
        std::cout << "Error: " << __LINE__ << std::endl;
        return EXIT_FAILURE;
    }

    context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
    if (!context || err != CL_SUCCESS)
    {
        std::cout << "Error: " << __LINE__ << std::endl;
        return EXIT_FAILURE;
    }

    host_queue = clCreateCommandQueueWithProperties(
        context, device_id, NULL, &err
    );
    if (!host_queue || err != CL_SUCCESS)
    {
        std::cout << "Error: " << __LINE__ << std::endl;
        return EXIT_FAILURE;
    }

    const cl_queue_properties queue_properties[] = {
        CL_QUEUE_PROPERTIES,
        CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE |
        CL_QUEUE_ON_DEVICE |
        CL_QUEUE_ON_DEVICE_DEFAULT,
        0
    };
    device_queue1 = clCreateCommandQueueWithProperties(
        context, device_id, queue_properties, &err
    );
    if (!device_queue1 || err != CL_SUCCESS)
    {
        std::cout << "Error: " << __LINE__ << std::endl;
        return EXIT_FAILURE;
    }
    std::cout << "Before 1st clGetCommandQueueInfo(host_queue, CL_QUEUE_DEVICE_DEFAULT, ..)" << std::endl;
    print_referene_count("device_queue1", device_queue1);

    // INC QUEUE REFERENCE COUNT
    err = clRetainCommandQueue(device_queue1);
    if (err != CL_SUCCESS)
    {
        std::cout << "Error: " << __LINE__ << std::endl;
        return EXIT_FAILURE;
    }
    std::cout << "After clRetainCommandQueue(device_queue1)" << std::endl;
    print_referene_count("device_queue1", device_queue1);

    // DECREASE QUEUE REFERENCE COUNT
    err = clReleaseCommandQueue(device_queue1);
    if (err != CL_SUCCESS)
    {
        std::cout << "Error: " << __LINE__ << std::endl;
        return EXIT_FAILURE;
    }
    std::cout << "After clReleaseCommandQueue(device_queue1)" << std::endl;
    print_referene_count("device_queue1", device_queue1);

    err = clGetCommandQueueInfo(
        host_queue,
        CL_QUEUE_DEVICE_DEFAULT,
        sizeof(cl_command_queue),
        &device_queue2,
        NULL
    );
    if (err != CL_SUCCESS)
    {
        std::cout << "Error: " << err << ", line: " << __LINE__ << std::endl;
        return EXIT_FAILURE;
    }
    std::cout << "After clGetCommandQueueInfo(host_queue, CL_QUEUE_DEVICE_DEFAULT, ..)" << std::endl;
    print_referene_count("device_queue1", device_queue1);
    print_referene_count("device_queue2", device_queue2);

    clReleaseCommandQueue(host_queue);
    clReleaseCommandQueue(device_queue1);
    clReleaseContext(context);
    return 0;
}