#include "app.hpp"

#include "utils.hpp"

#include <iostream>

using namespace std;

static std::vector<Vertex> generate_random_points(size_t N){
	std::vector<Vertex> ret(N);

	const float d = 0.1;
	for(auto& x : ret){
		x[0] = d * rand() / float(RAND_MAX);
		x[1] = d * rand() / float(RAND_MAX);
		x[2] = d * rand() / float(RAND_MAX);
	}

	return ret;
}

enum {
	POS_ATTR,
	TEX_ATTR
};

App::App(GLContext& gl_context)
: gl_vbo(create_vbo(generate_random_points(N)))
, gl_vao(create_vao(gl_vbo))
, gl_program(create_shader_from_files("Fractal.vsh", "Fractal.fsh"))
, cl_context(create_shared_cl_context(gl_context))
, cl_device(cl_context.getInfo<CL_CONTEXT_DEVICES>().front())
, cl_queue(cl_context, cl_device)
, cl_buffer(cl_context, 0, gl_vbo.id)
, cl_program(create_cl_program("Kernel.cl"))
, k_update(cl_program, "update")
{
	moggle::gl::clear_color(0.0f, 0.0f, 0.0f, 1.0f);

	moggle::gl::enable(GL_BLEND);
	moggle::gl::blend_function(GL_ONE, GL_ONE);
	moggle::gl::blend_equation(GL_FUNC_ADD);
}

void App::draw(){
	auto dt = 1/60.0;
	time += dt;
	if(wait > 0) wait -= dt;

	if(wait <= 0){
		k_update(cl_queue, N, p_s, p_r, p_b, p_dt, cl_buffer);
	}

	cl::checky(cl_queue.finish());

	moggle::gl::clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	gl_program.use();
	gl_vao.bind();

	moggle::gl::draw_arrays(GL_POINTS, 0, N);
}

void App::resize(size_t w, size_t h){
	wait = 5;

	W = w;
	H = h;
}

moggle::shader_program App::create_shader_from_files(string vertex, string fragment){
	moggle::shader_program program;

	auto vs = moggle::shader::from_file(moggle::shader_type::vertex, vertex);
	auto fs = moggle::shader::from_file(moggle::shader_type::fragment, fragment);

	program.attach(vs);
	program.attach(fs);

	program.bind_attribute(POS_ATTR, "position");

	program.link();

	return program;
}

moggle::vbo<Vertex> App::create_vbo(const std::vector<Vertex>& data){
	moggle::vbo<Vertex> vbo;
	vbo.bind(GL_ARRAY_BUFFER);
	vbo.data(data);
	return vbo;
}

moggle::vao App::create_vao(const moggle::vbo<Vertex>& vbo){
	moggle::vao vao;
	vao.bind();

	moggle::gl::enable_vertex_attribute_array(POS_ATTR);

	vao.attribute(POS_ATTR, vbo);

	return vao;
}

GLuint App::create_gl_texture(GLsizei width, GLsizei height){
	GLuint tex = 0;
	moggle::gl::active_texture(GL_TEXTURE0);
	moggle::gl::generate_textures(1, &tex);
	moggle::gl::bind_texture(GL_TEXTURE_2D, tex);
	moggle::gl::texture_image_2d(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
	moggle::gl::texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	moggle::gl::texture_parameter_i(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	return tex;
}

cl::Context App::create_shared_cl_context(GLContext& gl_context){
	CGLShareGroupObj sharegroup = CGLGetShareGroup(gl_context.ctx);

	cl_context_properties properties[] = {
	CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)sharegroup,
	0
	};

	cl_int err = 0;
	cl::Context cl_context(CL_DEVICE_TYPE_CPU, properties, nullptr, nullptr, &err);
	cl::checky(err);

	return cl_context;
}

cl::Program App::create_cl_program(string file){
	cl_int err = 0;

	// build the program
	cl::Program cl_program(cl_context, slurp(file), true, &err);
	cout << cl_program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(cl_device) << std::endl;

	cl::checky(err);
	cout << cl_program << endl;

	return cl_program;
}