#include "GL/glew.h"
#include "GLFW/glfw3.h"

#include "pwyazh.h"
#include "pwyazh_GL.h"

#include "common.h"

void render_scene(U32 shader, Mesh *cube)
{
	MAT4 model;

	model = mat4_identity();
	model = mat4_make_scale(v3f(5.0f, 5.0f, 5.0f));
	shader_set_mat4fv(shader, "model", model);
	glDisable(GL_CULL_FACE);
	shader_set_1i(shader, "reverse_normals", 1);
	mesh_draw(cube);
	shader_set_1i(shader, "reverse_normals", 0);
	glEnable(GL_CULL_FACE);

	model = mat4_identity();
	model = mat4_make_scale(v3f(0.5f, 0.5f, 0.5f));
	model = mat4_translate(model, v3f(0.0f, 1.5f, 0.0f));
	shader_set_mat4fv(shader, "model", model);
	mesh_draw(cube);

	model = mat4_identity();
	model = mat4_make_scale(v3f(0.5f, 0.5f, 0.5f));
	model = mat4_translate(model, v3f(2.0f, 0.0f, 1.0f));
	shader_set_mat4fv(shader, "model", model);
	mesh_draw(cube);

	model = mat4_identity();
	model = mat4_make_scale(v3f(0.25f, 0.25f, 0.25f));
	model = mat4_rotate_angles(model, v3f(60.0f, 0.0f, 0.0f));
	model = mat4_translate(model, v3f(-1.0f, 0.0f, 2.0f));
	shader_set_mat4fv(shader, "model", model);
	mesh_draw(cube);
}

int main(void)
{
	GLFWwindow *window;
	Arena *arena;
	State state;
	Input input;
	F64 time, last_time;
	V3F light_pos;
	MAT4 shadow_transforms[6];
	MAT4 proj, view;
	S32 screen_width, screen_height;

	glfwSetErrorCallback(error_callback);

	if (glfwInit() == GLFW_FALSE)
		return(1);

	screen_width = 800;
	screen_height = 600;

	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_SAMPLES, 4);
	window = glfwCreateWindow(screen_width, screen_height, "Point shadows", 0, 0);
	if (!window)
		goto error;

	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

	glfwMakeContextCurrent(window);

	if (glewInit() != GLEW_OK)
		goto error;

	glEnable(GL_DEPTH_TEST);
	glEnable(GL_CULL_FACE);

	/* NOTE(pryazha): Init */
	arena = arena_alloc(Megabytes(64));

	state.camera = (Camera){
		.pos = v3f(0.0f, 1.0f, 3.0f),
			.fovx = 100.0f,
			.near = 0.1f,
			.far = 100.0f,
			.yaw = 0.0f,
			.pitch = 0.0f
	};
	V3F camera_dp = v3f_zero();
	/* light_pos = v3f(-2.0f, 4.0f, -2.0f); */
	light_pos = v3f_zero();

	/* NOTE(pryazha): Meshes */
	Mesh *cube = mesh_load_obj(arena, "../../data/models/cube.obj");

	F32 quad_vertices[] = {
		-1.0f, -1.0f,  0.0f,   0.0f, 0.0f,
		1.0f, -1.0f,  0.0f,   1.0f, 0.0f,
		1.0f,  1.0f,  0.0f,   1.0f, 1.0f,
		-1.0f, -1.0f,  0.0f,   0.0f, 0.0f,
		1.0f,  1.0f,  0.0f,   1.0f, 1.0f,
		-1.0f,  1.0f,  0.0f,   0.0f, 1.0f
	};
	U32 quad_vao, vbo;
	glGenVertexArrays(1, &quad_vao);
	glBindVertexArray(quad_vao);
	glGenBuffers(1, &vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(quad_vertices), quad_vertices, GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(F32), (void *)0);
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(F32), (void *)(3*sizeof(F32)));
	glBindVertexArray(0);

	/* NOTE(pryazha): Shaders */
	U32 depth_shader = create_shader_program_geom("shaders/depth.vert",
						      "shaders/depth.frag",
						      "shaders/depth.geom");
	U32 shadow_shader = create_shader_program("shaders/shadow.vert",
						  "shaders/shadow.frag");

	glUseProgram(shadow_shader);
	shader_set_1i(shadow_shader, "diffuse_texture", 0);
	shader_set_1i(shadow_shader, "depth_cubemap", 1);
	glUseProgram(0);

	U32 wood_texture = load_texture_gamma("../../data/textures/wood.png", 0);

	/* NOTE(pryazha): Depth framebuffer init */
	U32 depth_cubemap_fbo, depth_cubemap;
	U32 shadow_width = 1024, shadow_height = 1024;
	glGenFramebuffers(1, &depth_cubemap_fbo);
	glGenTextures(1, &depth_cubemap);
	glBindTexture(GL_TEXTURE_CUBE_MAP, depth_cubemap);
	for (U32 cubemap_side = 0; cubemap_side < 6; ++cubemap_side)
		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+cubemap_side, 0, GL_DEPTH_COMPONENT,
			     shadow_width, shadow_height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_BORDER);
	glBindFramebuffer(GL_FRAMEBUFFER, depth_cubemap_fbo);
	glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_cubemap, 0);
	glDrawBuffer(GL_NONE);
	glReadBuffer(GL_NONE);
	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		fprintf(stderr, "[ERROR]: Failed to complete depth map framebuffer.\n");
	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	last_time = glfwGetTime();

	while (!glfwWindowShouldClose(window)) {
		glfwPollEvents();

		/* NOTE(pryazha): For now it's easier to write all of the logic in the main loop */
		/* NOTE(pryazha): Update */
		F32 x, y, z, angular_speed, radius;

		glfwGetFramebufferSize(window, &screen_width, &screen_height);
		process_glfw_keyboard(window, &input);
		process_glfw_mouse_pos(window, &input);

		if (key_first_press(input.exit))
			glfwSetWindowShouldClose(window, GLFW_TRUE);

		F32 speed = 4.0f;
		V3F dv = get_dv_camera_first_person(&input, &state.camera,
						    speed, state.dt);
		if (key_is_pressed(input.action_up))
			dv = v3f_scalef(dv, 3.0f);
		camera_dp = v3f_add(camera_dp, dv);
		camera_dp = v3f_scalef(camera_dp, 0.8f);
		state.camera.pos = v3f_add(state.camera.pos, camera_dp);

		F32 sensitivity = 0.1f;
		input.mouse_offset = v2f_scalef(input.mouse_offset, sensitivity);
		state.camera.yaw += input.mouse_offset.x;
		state.camera.pitch += input.mouse_offset.y;
		if (state.camera.pitch > 89.0f)
			state.camera.pitch = 89.0f;
		if (state.camera.pitch < -89.0f)
			state.camera.pitch = -89.0f;

		input_update_last_state(&input);

		angular_speed = 1.0f;
		radius = 4.0f;
		x = f32_sin(time*angular_speed)*radius;
		y = f32_sin(time*angular_speed)*f32_sin(time*angular_speed)*radius;
		z = f32_cos(time*angular_speed)*radius;

		light_pos = v3f(x, y, z);

		/* NOTE(pryazha): Render */

		/* NOTE(pryazha): Render the depth cubemap */
		F32 fovx, aspect, near, far;
		fovx = 90.0f;
		aspect = (F32)shadow_width/(F32)shadow_height;
		near = 1.0f;
		far = 25.0f;
		proj = perspective(fovx, aspect, near, far);
		shadow_transforms[0] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 1.0f,  0.0f,  0.0f)), v3f(0.0f, -1.0f,  0.0f))); /* right */
		shadow_transforms[1] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f(-1.0f,  0.0f,  0.0f)), v3f(0.0f, -1.0f,  0.0f))); /* left */
		shadow_transforms[2] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 0.0f,  1.0f,  0.0f)), v3f(0.0f,  0.0f,  1.0f))); /* top */
		shadow_transforms[3] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 0.0f, -1.0f,  0.0f)), v3f(0.0f,  0.0f, -1.0f))); /* bottom */
		shadow_transforms[4] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 0.0f,  0.0f,  1.0f)), v3f(0.0f, -1.0f,  0.0f))); /* near */
		shadow_transforms[5] = mat4_mul(proj, look_at(light_pos, v3f_add(light_pos, v3f( 0.0f,  0.0f, -1.0f)), v3f(0.0f, -1.0f,  0.0f))); /* far */
		glViewport(0, 0, shadow_width, shadow_height);
		glBindFramebuffer(GL_FRAMEBUFFER, depth_cubemap_fbo);
		glClear(GL_DEPTH_BUFFER_BIT);
		glUseProgram(depth_shader);
		shader_set_1f(depth_shader, "far", far);
		shader_set_3fv(depth_shader, "light_pos", light_pos);
		for (U32 i = 0; i < 6; ++i) {
			char uniform_name[256];
			snprintf(uniform_name, 256, "shadow_transforms[%d]", i);
			shader_set_mat4fv(depth_shader, uniform_name, shadow_transforms[i]);
		}
		render_scene(depth_shader, cube);
		glBindFramebuffer(GL_FRAMEBUFFER, 0);

		/* NOTE(pryazha): Render the scene as normal */
		glViewport(0, 0, screen_width, screen_height);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		glUseProgram(shadow_shader);

		aspect = (F32)screen_width/(F32)screen_height;
		proj = perspective(state.camera.fovx, aspect, state.camera.near, state.camera.far);
		view = get_view_matrix(&state.camera);

		shader_set_mat4fv(shadow_shader, "proj", proj); 
		shader_set_mat4fv(shadow_shader, "view", view);
		shader_set_3fv(shadow_shader, "light_pos", light_pos);
		shader_set_3fv(shadow_shader, "view_pos", state.camera.pos);
		shader_set_1f(shadow_shader, "far", far);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, wood_texture);
		glActiveTexture(GL_TEXTURE1);
		glBindTexture(GL_TEXTURE_CUBE_MAP, depth_cubemap);
		render_scene(shadow_shader, cube);

		glfwSwapBuffers(window);

		time = glfwGetTime();
		state.dt = time-last_time;
		last_time = time;
	}

	glfwTerminate();
	return(0);

error:
	glfwTerminate();
	return(1);
}