//DebugShape class

class DebugShape
{
public:
	DebugShape(uint num_vertices, float* vertices, uint num_indices, uint* indices);

	void CleanUp();

	void SetTransform(float4x4 transform);
	void SetColour(float4 colour);
	void SetMode(int mode);

	void SetStroke(uint stroke);

	uint GetNumVertices();
	float* GetVertices();
	uint GetNumIndices();
	uint* GetIndices();
	float4 GetColour();
	float4x4 GetTransform();
	int GetMode();

	uint GetStroke();

private:
	uint     num_vertices = 0;
	float*   vertices = nullptr;
	uint     num_indices = 0;
	uint*    indices = nullptr;

	float4   colour = float4::zero;

	float4x4 transform = float4x4::identity;
	int      mode = 0x0004;

	uint     stroke = 1;
};



DebugShape::DebugShape(uint _num_vertices, float * _vertices, uint _num_indices, uint * _indices)
{
	if (_num_vertices > 0)
	{
		// Vertices
		vertices = new float[_num_vertices * 3];
		memcpy(vertices, _vertices, sizeof(float) * _num_vertices * 3);
		num_vertices = _num_vertices;

		if (_num_indices > 0)
		{
			// Indices
			indices = new uint[_num_indices];
			memcpy(indices, _indices, sizeof(uint) * _num_indices);
			num_indices = _num_indices;
		}
	}

	mode = GL_TRIANGLES;
	transform = float4x4::identity;
	colour = float4(1.0f, 1.0f, 1.0f, 1.0f);
}

void DebugDraw::Line(float3 start, float3 end, float4 colour)
{
	uint num_vertices = 2;
	uint num_indices = 2;

	float* vertices = new float[num_vertices * 3];
	uint* indices = new uint[num_indices];

	vertices[0] = start.x;
	vertices[1] = start.y;
	vertices[2] = start.z;

	vertices[3] = end.x;
	vertices[4] = end.y;
	vertices[5] = end.z;

	indices[0] = 0;
	indices[1] = 1;

	DebugShape shape(num_vertices, vertices, num_indices, indices);
	shape.SetMode(GL_LINES);
	shape.SetColour(colour);
	shape.SetStroke(line_stroke);

	AddShape(shape);

	delete[] vertices;
	delete[] indices;
}

void DebugDraw::Quad(float3 center, float2 size, float4 colour)
{
	uint num_vertices = 4;
	uint num_indices = 8;

	float* vertices = new float[num_vertices * 3];
	uint* indices = new uint[num_indices];

	float3 up_left = float3(center.x - (size.x/2), center.y + (size.y/2), center.z);
	float3 down_left = float3(center.x - (size.x/2), center.y - (size.y/2), center.z);
	float3 down_right = float3(center.x + (size.x / 2), center.y - (size.y / 2), center.z);
	float3 up_right = float3(center.x + (size.x / 2), center.y + (size.y / 2), center.z);

	vertices[0] = up_left.x;
	vertices[1] = up_left.y;
	vertices[2] = up_left.z;

	vertices[3] = down_left.x;
	vertices[4] = down_left.y;
	vertices[5] = down_left.z;

	vertices[6] = down_right.x;
	vertices[7] = down_right.y;
	vertices[8] = down_right.z;

	vertices[9] = up_right.x;
	vertices[10] = up_right.y;
	vertices[11] = up_right.z;

	indices[0] = 0;
	indices[1] = 1;

	indices[2] = 1;
	indices[3] = 2;

	indices[4] = 2;
	indices[5] = 3;

	indices[6] = 3;
	indices[7] = 0;

	DebugShape shape(num_vertices, vertices, num_indices, indices);
	shape.SetMode(GL_LINES);
	shape.SetColour(colour);

	shape.SetStroke(line_stroke);

	AddShape(shape);

	delete[] vertices;
	delete[] indices;
}

void DebugDraw::Quad(float4x4 transform, float2 size, float4 colour)
{
	uint num_vertices = 4;
	uint num_indices = 8;

	float* vertices = new float[num_vertices * 3];
	uint* indices = new uint[num_indices];

	float3 up_left = float3(-(size.x / 2), (size.y / 2), 0);
	float3 down_left = float3(-(size.x / 2), -(size.y / 2), 0);
	float3 down_right = float3((size.x / 2), -(size.y / 2), 0);
	float3 up_right = float3((size.x / 2), (size.y / 2), 0);

	vertices[0] = up_left.x;
	vertices[1] = up_left.y;
	vertices[2] = up_left.z;

	vertices[3] = down_left.x;
	vertices[4] = down_left.y;
	vertices[5] = down_left.z;

	vertices[6] = down_right.x;
	vertices[7] = down_right.y;
	vertices[8] = down_right.z;

	vertices[9] = up_right.x;
	vertices[10] = up_right.y;
	vertices[11] = up_right.z;

	indices[0] = 0;
	indices[1] = 1;

	indices[2] = 1;
	indices[3] = 2;

	indices[4] = 2;
	indices[5] = 3;

	indices[6] = 3;
	indices[7] = 0;

	DebugShape shape(num_vertices, vertices, num_indices, indices);
	shape.SetMode(GL_LINES);
	shape.SetTransform(transform);
	shape.SetColour(colour);
	shape.SetStroke(line_stroke);

	AddShape(shape);

	delete[] vertices;
	delete[] indices;
}

void DebugDraw::Circle(float4x4 transform, float rad, float4 colour, uint resolution)
{
	int slices = resolution;

	float angle_slice = 360 / slices;

	uint num_vertices = slices;
	uint num_indices = slices*2;

	float* vertices = new float[num_vertices * 3];
	uint* indices = new uint[num_indices];

	float curr_angle = 0;
	for(int i = 0; i < slices; i++)
	{
		vertices[(i * 3)] = cos(curr_angle * DEGTORAD) * rad;
		vertices[(i * 3) + 1] = sin(curr_angle * DEGTORAD) * rad;
		vertices[(i * 3) + 2] = 0;

		curr_angle += angle_slice;

		indices[i*2] = i;

		if (i+1 < slices)
			indices[(i * 2) + 1] = i + 1;
		else
			indices[(i * 2) + 1] = 0;
	}

	DebugShape shape(num_vertices, vertices, num_indices, indices);
	shape.SetMode(GL_LINES);
	shape.SetTransform(transform);
	shape.SetColour(colour);
	shape.SetStroke(line_stroke);

	AddShape(shape);

	delete[] vertices;
	delete[] indices;
}

void DebugDraw::AddShape(DebugShape shape)
{
	shapes.push_back(shape);
}

void DebugDraw::Render(ComponentCamera* camera)
{
	if (shapes.empty()) return;

	// Activate
	GLenum last_active_texture; glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint*)&last_active_texture);
	glActiveTexture(GL_TEXTURE0);
	GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
	GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
	GLint last_sampler; glGetIntegerv(GL_SAMPLER_BINDING, &last_sampler);
	GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
	GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
	GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
	GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode);
	GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
	GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
	GLenum last_blend_src_rgb; glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*)&last_blend_src_rgb);
	GLenum last_blend_dst_rgb; glGetIntegerv(GL_BLEND_DST_RGB, (GLint*)&last_blend_dst_rgb);
	GLenum last_blend_src_alpha; glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*)&last_blend_src_alpha);
	GLenum last_blend_dst_alpha; glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*)&last_blend_dst_alpha);
	GLenum last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*)&last_blend_equation_rgb);
	GLenum last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*)&last_blend_equation_alpha);
	GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
	GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
	GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
	GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);

	glEnable(GL_BLEND);
	glBlendEquation(GL_FUNC_ADD);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glDisable(GL_CULL_FACE);
	glDisable(GL_DEPTH_TEST);
	glEnable(GL_CULL_FACE);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_SCISSOR_TEST);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

	// Render ----
	uint program = App->resources->GetShaderProgram("default_debug_program")->GetProgramID();
	App->renderer3D->UseShaderProgram(program);

	App->renderer3D->SetUniformMatrix(program, "view", camera->GetViewMatrix());
	App->renderer3D->SetUniformMatrix(program, "projection", camera->GetProjectionMatrix());

	uint vao;
	glGenVertexArrays(1, (GLuint*)&vao);

	float4 color = float4::zero;

	for (std::vector<DebugShape>::iterator it = shapes.begin(); it != shapes.end(); ++it)
	{
		glLineWidth((*it).GetStroke());

		uint id_vertices_data = 0;
		uint id_indices = 0;

		float4x4 trans = (*it).GetTransform();
		float4 current_colour = (*it).GetColour();
		int mode = (*it).GetMode();
		
		App->renderer3D->SetUniformMatrix(program, "Model", trans.Transposed().ptr());

		if (!current_colour.Equals(color))
		{
			App->renderer3D->SetUniformVector4(program, "debug_color", current_colour);
		}

		glGenBuffers(1, &id_vertices_data);
		glBindBuffer(GL_ARRAY_BUFFER, id_vertices_data);
		glBufferData(GL_ARRAY_BUFFER, sizeof(float) * (*it).GetNumVertices() * 3, (*it).GetVertices(), GL_DYNAMIC_DRAW);

		glBindVertexArray(vao);
		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0 * sizeof(GLfloat), (void*)(0 * sizeof(GLfloat)));
		glEnableVertexAttribArray(0);

		glGenBuffers(1, &id_indices);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id_indices);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint) * (*it).GetNumIndices(), (*it).GetIndices(), GL_DYNAMIC_DRAW);

		glDrawElements(GL_TRIANGLES, (*it).GetNumIndices(), GL_UNSIGNED_INT, nullptr);

		glBindBuffer(GL_ARRAY_BUFFER, 0);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
		glDeleteBuffers(1, &id_vertices_data);
		glDeleteBuffers(1, &id_indices);

		glBindVertexArray(0);
		
	}

	glDeleteVertexArrays(1, &vao);

	// -----------

	// DeActivate
	glLineWidth(1);
	App->renderer3D->UseShaderProgram(last_program);
	glBindTexture(GL_TEXTURE_2D, last_texture);
	glBindSampler(0, last_sampler);
	glActiveTexture(last_active_texture);
	glBindVertexArray(last_vertex_array);
	glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
	glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
	glBlendFuncSeparate(last_blend_src_rgb, last_blend_dst_rgb, last_blend_src_alpha, last_blend_dst_alpha);
	if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
	if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
	if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
	if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
	glPolygonMode(GL_FRONT_AND_BACK, last_polygon_mode[0]);
	glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
	glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
}

//////////////////////////////////

//Vertex Shader

#version 330 core
layout(location = 0) in vec3 position;
uniform mat4 Model;
uniform mat4 view;
uniform mat4 projection;

void main()
{ 
	gl_Position = projection * view * Model * vec4(position, 1.0f);
}

//Fragment Shader

#version 330 core
out vec4 color;

uniform vec4 debug_color;
void main()
{
	color = debug_color;
}