#include <glm/glm.hpp>

#include "dumbLog.h"
#include "input.h"
#include "mesh.h"
#include "renderer.h"


simple_mesh*
makeSquareMesh()
{
	uint num_vertices = 4;
	simple_mesh* sm = meInitMesh(num_vertices);
	sm->num_vertices = num_vertices;

	sm->vertices[0] = glm::vec3(-200, 0, 200);
	sm->vertices[1] = glm::vec3(-200, 0, -200);
	sm->vertices[2] = glm::vec3(200, 0, -200);
	sm->vertices[3] = glm::vec3(200, 0, 200);
	sm->vert_colors[0] = glm::vec3(255, 0, 0);
	sm->vert_colors[1] = glm::vec3(255, 0, 0);
	sm->vert_colors[2] = glm::vec3(255, 0, 0);
	sm->vert_colors[3] = glm::vec3(255, 0, 0);

	return sm;
}

void
doFrameCallbackPre(render_state* rs)
{
	static input_state is = {};
	inputProcessEvents(&is);

	if (is.window_closed || is.escape) {
		rs->running = false;
		return;
	}

	// NOTE: rotate meshes on z-axis every frame
	const float deg_angle = 3; // NOTE: angle to rotate per frame in degrees
	static float angle = (float) deg_angle * M_PI_2 / 360;
	static glm::vec3 axis(0, 0, 1);

	entity& ship = rs->render_groups[0]->entities[0];
	entRotate(ship, angle , axis);
	entity& sphere = rs->render_groups[0]->entities[1];
	entRotate(sphere, angle , axis);
	entity& square = rs->render_groups[1]->entities[0];
	entRotate(square, -1 * angle , axis);
}

int
main()
{
	render_state* rs = renInit("render group example");

	if (rs == nullptr) {
		LOG(Error) << "Error Initialzing renderer\n";
		return 1;
	}

	cameraInitPerspective(
		rs->cam,
		glm::vec3(50, -100, 25),
		glm::vec3(0, 0, 0),
		glm::vec3(0,0,1)
	);

	renAddLight(rs, glm::vec3(-20, -150, 150));

	// FIXME: this introduces a potential buffer overrun. Need to implement
	//	a memory manager for render_groups, eg:
	//		renPushGroup(rs, new_group)
	//		rgPushEntity(rg, new_ent)
	rs->render_groups = UTIL_ALLOC(256, render_group*);

	// TODO: this needs to be more convenient
	shader_wrapper sw = { DEFAULT_SHADER, rs->default_shader, nullptr };
	rs->render_groups[0] = renAllocateGroup(2, sw);
	rs->render_group_count = 1;
	entity& spaceship = rs->render_groups[0]->entities[0];
	entity& sphere = rs->render_groups[0]->entities[1];

	if (!entInitModel(spaceship, "../data/spaceship.glb") ||
		!entInitModel(sphere, "../data/icosphere.glb"))
	{
		LOG(Error) << "Error initializing entity, exiting\n";
		return 1;
	}

	entSetWorldPosition(spaceship, glm::vec3(-50, 0, 0));
	entScale(spaceship, glm::vec3(2, 2, 2));
	entScale(sphere, glm::vec3(20, 20, 20));

	shader_wrapper sw2 = { SIMPLE_SHADER, nullptr, rs->simple_shader };
	rs->render_groups[1] = renAllocateGroup(1, sw2);
	rs->render_group_count++;

	entity& square = rs->render_groups[1]->entities[0];
	simple_mesh* sm = makeSquareMesh();

	// TODO: better usage would be: renPushEntity(rs->render_groups[0], e);
	// 	would need to allocate a reasonable block size by default (~64), and
	// 	double it if pushing to render_group would overflow
	entInitMesh(square, sm, GL_LINE_LOOP);
	entScale(square, glm::vec3(0.2, 0.2, 0.2));

	renDoRenderLoop(rs, 60, doFrameCallbackPre);

	renShutdown(rs);
	return 0;
}