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

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

#define WIDTH 512
#define HEIGHT 512

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

float *generate_data_surface(unsigned int, unsigned char *);
float *generate_normals_surface(float *, unsigned char);

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

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

unsigned char palette[][4] = {
	{0xEB, 0xD3, 0xF8, 0xff},
	{0xEB, 0xD4, 0xF8, 0xff},
	{0xEB, 0xD5, 0xF8, 0xff},
	{0x7A, 0x1C, 0xAC, 0xff},
};

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

window_t window;
mesh_t m_surface, m_axis;
id_t shader, shader_plain;

#ifndef EMSCRIPTEN
static inline
#endif
void main_loop(void)
{
	quat_t q;

	q = poll_input(window);
	load_rot_matrix(shader, q);
	load_rot_matrix(shader_plain, q);

	clean_context();

#ifndef DEBUG
	load_mdl_matrix(shader_plain, 0, 0);
	draw_mesh(m_axis);
	load_mdl_matrix(shader_plain, 1, 1);
	draw_mesh(m_axis);
	load_mdl_matrix(shader_plain, 2, 2);
	draw_mesh(m_axis);
	load_mdl_matrix(shader, 0, 3);
#else
	load_mdl_matrix(shader_plain, 0, 3);
#endif
	draw_mesh(m_surface);
}

int main(void)
{
	id_t texture;

	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(0x2E, 0x07, 0x3F);
	}

	mlog("[TEXTURE] Inicializando...\n");
	{
		texture = create_palette_texture(palette, 4);
		use_texture(texture);
	}

	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);
		load_fix_matrix(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);
		load_fix_matrix(shader_plain, (float)WIDTH / HEIGHT);
	}

	mlog("[MESH] Inicializando...\n");
	{
		unsigned char m;
		float *n_surface, *d_surface;
		d_surface = generate_data_surface(16, &m);
		n_surface = generate_normals_surface(d_surface, m);

		projection.m = m;

		if (!(m_surface = create_mesh(d_surface, n_surface, m)))
		{
			mlog("[MESH] Error al inicializar...\n");
			goto error_mesh_surface;
		}

		projection.mesh = m_surface;

		free(n_surface);
		free(d_surface);
	}

	mlog("[MESH] Inicializando...\n");
	{
		if (!(m_axis = create_mesh(d_axis, NULL, 3)))
		{
			mlog("[MESH] Error al inicializar...\n");
			goto error_mesh_axis;
		}
	}

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

	mlog("[MESH] Destruyendo...\n");
	destroy_mesh(m_axis);
	mlog("[MESH] Destruyendo...\n");
	destroy_mesh(m_surface);
	mlog("[SHADER] Destruyendo...\n");
	destroy_shader(shader_plain);
	mlog("[SHADER] Destruyendo...\n");
	destroy_shader(shader);
	mlog("[TEXTURE] Destruyendo...\n");
	destroy_texture(texture);
	mlog("[WINDOW] Destruyendo...\n");
	close_window(window);
	return 0;

	mlog("[MESH] Destruyendo...\n");
	destroy_mesh(m_axis);
error_mesh_axis:
	mlog("[MESH] Destruyendo...\n");
	destroy_mesh(m_surface);
error_mesh_surface:
	mlog("[SHADER] Destruyendo...\n");
	destroy_shader(shader_plain);
error_shader_plain:
	mlog("[SHADER] Destruyendo...\n");
	destroy_shader(shader);
error_shader:
	mlog("[TEXTURE] Destruyendo...\n");
	destroy_texture(texture);
error_context:
	mlog("[WINDOW] Destruyendo...\n");
	close_window(window);
error_window:
	return 1;
}