#define __CL_ENABLE_EXCEPTIONS
#include <CL/cl.h>
#include <libclew/ocl_init.h>

#include <vector>
#include <sstream>
#include <iostream>
#include <stdexcept>
#include <vector>
#include <fstream>
#include <iostream>
#include <iterator>
#include <iomanip>
#include <memory>
#include "../cl.hpp"


template <typename T>
std::string to_string(T value)
{
    std::ostringstream ss;
    ss << value;
    return ss.str();
}

void reportErr(cl_int err, const std::string& filename, int line)
{
    if (CL_SUCCESS == err)
        return;
    const std::string message = "OpenCL error code " + to_string(err) + " encountered at " + filename + ":" +
        to_string(line);
    throw std::runtime_error(message);
}

#define OCL_SAFE_CALL(expr) reportErr(expr, __FILE__, __LINE__)

#define _CRT_SECURE_NO_WARNINGS

std::unique_ptr<double[]> read_matrix(size_t matrix_size)
{
    std::unique_ptr<double[]> result(new double[matrix_size]());
    for (size_t i = 0; i < matrix_size; i++)
    {
        std::cin >> result.get()[i];
    }
    return result;
}


int main()
{
    if (!ocl_init())
        throw std::runtime_error("Can't init OpenCL driver!");

    std::vector<cl::Platform> platforms;
    std::vector<cl::Device> devices;
    std::vector<cl::Kernel> kernels;
    std::ofstream input("input.txt");
#ifdef DEBUG
    int N = 1;
    int M = 9;

    input << N << " " << M << "\n";
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            input << 1 << " ";
        }
        input << "\n";
    }
    for (int i = 0; i < M; i++)
    {
        for (int j = 0; j < M; j++)
        {
            input << 1 << " ";
        }
        input << "\n";
    }
    input.flush();
#endif
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    int n, m;
    std::cin >> n >> m;
    size_t matrix_size = n * n;
    size_t kernel_matrix_size = m * m;
    auto a = read_matrix(matrix_size);
    auto b = read_matrix(kernel_matrix_size);
    std::unique_ptr<double[]> result(new double[matrix_size]());
    try
    {
        // create platform
        cl::Platform::get(&platforms);
        platforms[0].getDevices(CL_DEVICE_TYPE_CPU, &devices);

        // create context
        cl::Context context(devices);

        // create command queue
        cl::CommandQueue queue(context, devices[0]);

        // load opencl source
        std::ifstream cl_file("matrix_convolution.cl");
        std::string cl_string(std::istreambuf_iterator<char>(cl_file), (std::istreambuf_iterator<char>()));
        cl::Program::Sources source(1, std::make_pair(cl_string.c_str(),
                                                      cl_string.length() + 1));

        // create program
        cl::Program program(context, source);

        // compile opencl source
        size_t const block_size = 16;
        program.build(devices, "-D BLOCK_SIZE=16");

        // allocate device buffer to hold message
        cl::Buffer dev_a(context, CL_MEM_READ_ONLY, sizeof(double) * matrix_size);
        cl::Buffer dev_b(context, CL_MEM_READ_ONLY, sizeof(double) * kernel_matrix_size);
        cl::Buffer dev_c(context, CL_MEM_WRITE_ONLY, sizeof(double) * matrix_size);

        // copy from cpu to gpu
        queue.enqueueWriteBuffer(dev_a, CL_TRUE, 0, sizeof(double) * matrix_size, a.get());
        queue.enqueueWriteBuffer(dev_b, CL_TRUE, 0, sizeof(double) * kernel_matrix_size, b.get());

        // load named kernel from opencl source
        cl::Kernel kernel(program, "matrix_convolution");
        cl::KernelFunctor matrix_convolution(kernel, queue, cl::NullRange, cl::NDRange(n, n),
                                             cl::NDRange(block_size, block_size));
        matrix_convolution(dev_a, dev_b, dev_c, n, m);


        queue.enqueueReadBuffer(dev_c, CL_TRUE, 0, sizeof(double) * matrix_size, result.get());
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                std::cout << result.get()[i * n + j] << " ";
            }
            std::cout << std::endl;
        }
    }
    catch (cl::Error& e)
    {
        std::cerr << std::endl << e.what() << " : " << e.err() << "\n";
    }

    return 0;
}