#include "main.h"
#include "data/shaders.h"

#include <stdio.h>
#include <stdlib.h>

#define WIDTH 512
#define HEIGHT 512

#ifdef EMSCRIPTEN
#include <emscripten.h>
#endif

#ifndef M_PI
#define M_PI 3.14159
#endif

struct projection projection = {.x = 0, .y = 1, .z = 2, .w = 3, .mesh = NULL};

const char *wname = "manigraph: manifold grapher";

unsigned char color[4] = {0x2F, 0x3C, 0x7E, 0xff};

void mlog(char *msg)
{
#ifdef DEBUG
	printf(msg);
#endif
}

window_t window;
id_t shader, shader_plain;

extern volatile unsigned char animate_index;

#ifndef EMSCRIPTEN
static inline
#endif

	void
	main_loop(void)
{
	quat_t q;

	q = poll_input(window);

	rot_matrix_load(shader, q);
	rot_matrix_load(shader_plain, q);
	color_load(shader, color);
	color_load(shader_plain, color);

	{
		static float angle = 0;

		if (angle > M_PI / 2)
		{
			animate_index = 0;
			angle = 0;

			load_float_to_shader(shader, "angle", angle);
			load_float_to_shader(shader_plain, "angle", angle);
			set_projection_mesh(projection);
		}

		if (animate_index)
		{
			load_float_to_shader(shader, "i", animate_index - 1);
			load_float_to_shader(shader_plain, "i", animate_index - 1);

			angle += 0.01;
			load_float_to_shader(shader, "angle", angle);
			load_float_to_shader(shader_plain, "angle", angle);
		}
	}
	clean_context();

	if (!projection.mesh)
		return;

	draw_mesh(shader, projection.mesh);
	draw_mesh_lines(shader_plain, projection.mesh);
}

int main(void)
{

	mlog("[VENTANA] Inicializando...\n");
	{
		if (!(window = init_window(WIDTH, HEIGHT, wname)))
		{
			mlog("[VENTANA] Error al inicializar...\n");
			goto error_window;
		}

		use_window(window);
	}

	mlog("[CONTEXT] Inicializando...\n");
	{
		if (!(init_context()))
		{
			mlog("[CONTEXT] Error al inicializar...\n");
			goto error_context;
		}
		set_clean_color_context(0xFF, 0xFF, 0xFF);
	}

	mlog("[SHADER] Inicializando...\n");
	{
		if (!(shader = create_shader()))
		{
			mlog("[SHADER] Error al inicializar...\n");
			goto error_shader;
		}
		load_program_to_shader(shader, vs, VERTEX);
		load_program_to_shader(shader, fs, FRAGMENT);
		fix_matrix_load(shader, (float)WIDTH / HEIGHT);
	}

	mlog("[SHADER] Inicializando...\n");
	{
		if (!(shader_plain = create_shader()))
		{
			mlog("[SHADER] Error al inicializar...\n");
			goto error_shader_plain;
		}
		load_program_to_shader(shader_plain, vs, VERTEX);
		load_program_to_shader(shader_plain, fs_plain, FRAGMENT);
		fix_matrix_load(shader_plain, (float)WIDTH / HEIGHT);
	}

	mlog("[MAIN LOOP] Inicializando...\n");
#ifdef EMSCRIPTEN
	emscripten_set_main_loop(&main_loop, 60, 1);
	return 0;
#else
	while (is_open_window(window))
		main_loop();
#endif
	mlog("[MAIN LOOP] Terminando...\n");

	mlog("[MESH] Destruyendo...\n");
	destroy_mesh(projection.mesh);
	mlog("[SHADER] Destruyendo...\n");
	destroy_shader(shader_plain);
	mlog("[SHADER] Destruyendo...\n");
	destroy_shader(shader);
	mlog("[WINDOW] Destruyendo...\n");
	close_window(window);
	return 0;

error_context:
	mlog("[SHADER] Destruyendo...\n");
	destroy_shader(shader_plain);
error_shader_plain:
	mlog("[SHADER] Destruyendo...\n");
	destroy_shader(shader);
error_shader:
	mlog("[WINDOW] Destruyendo...\n");
	close_window(window);
error_window:
	return 1;
}