#include "MyObjectOrientedScene.h"

#include <cmath>
#include <iostream>

#include "constants.h"

#include "Util.h"

#include "DrawMode.h"
#include "MeshFactory.h"

#define FIRST_VERT -50.0f, 50.0f, 0.0f

MyObjectOrientedScene::MyObjectOrientedScene(Application& application)
	: Scene(application),
	m_shape(MeshFactory<MyBatchTestShaderProgram::Vertex, MyBatchTestShaderProgram::Index>::gen(
		DrawMode::DRAW_TRIANGLES,
		MyBatchTestShaderProgram::Vertex(FIRST_VERT),
		MyBatchTestShaderProgram::Vertex(50.0f, 150.0f, 0.0f),
		MyBatchTestShaderProgram::Vertex(-100.0f, -50.0f, 0.0f),
		MyBatchTestShaderProgram::Vertex(100.0f, -50.0f, 0.0f)
	), DrawMode::DRAW_TRIANGLES),
	m_batch(&m_shape, 2),
	m_camera(vec3(m_screen_size, 4.0f))// TODO: change this back to just m_screen_size
{
}

MyObjectOrientedScene::~MyObjectOrientedScene()
{
}

void MyObjectOrientedScene::init()
{
	m_batch.init();
}

void MyObjectOrientedScene::use()
{
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);
}

void MyObjectOrientedScene::unuse()
{

}

void MyObjectOrientedScene::update(float delta_time, clock_t clock)
{
	float brightness;
	float radians;

	clock_t c;
	const clock_t intervals = 512 * CLOCKS_PER_SEC / 100;
	const clock_t half_interval = 256 * CLOCKS_PER_SEC / 100;
	c = clock % intervals;
	if (c < half_interval)
		brightness = (float)c / half_interval;
	else
		brightness = (float)(intervals - c) / half_interval;
	
	radians = (float)egm::TAU * c / intervals;

	{
		MyBatchTestShaderProgram::Color& color = m_batch.get_color(0);
		color.r = brightness;
		color.g = brightness;
		color.b = brightness;
		color.a = 1.0f;

		Poseable& pose = m_batch.get_pose(0);
		pose.update_position(vec3(3 * (float)cos(radians), 0.0f, 0.0f));
	}
	
	{
		MyBatchTestShaderProgram::Color& color = m_batch.get_color(1);
		color.r = 1.0f - brightness;
		color.g = 1.0f - brightness;
		color.b = 1.0f - brightness;
		color.a = 1.0f;

		Poseable& pose = m_batch.get_pose(1);
		pose.update_position(vec3(0.0f, 3 * (float)sin(radians), 0.0f));
	}

	vec2 camera_translation(0.0f, 0.0f);

	if (m_input_manager.is_key_down(GLFW_KEY_W)) camera_translation.y += 1;
	if (m_input_manager.is_key_down(GLFW_KEY_S)) camera_translation.y -= 1;
	if (m_input_manager.is_key_down(GLFW_KEY_A)) camera_translation.x -= 1;
	if (m_input_manager.is_key_down(GLFW_KEY_D)) camera_translation.x += 1;

	m_camera.translate(camera_translation * delta_time * 100.0f);

	const mat4& world_to_view = m_camera.get_world_to_view_matrix();
	const mat4& orientation = m_batch.get_pose(0).get_orientation_matrix();
	vec4 first_vert(FIRST_VERT, 1.0f);

	Util::set_console_position(0, 0);
	std::cout << "World to View" << std::endl;
	Util::print_matrix(m_camera.get_world_to_view_matrix());
	std::cout << "Pose 0 Orientation" << std::endl;
	Util::print_matrix(m_batch.get_pose(0).get_orientation_matrix());
	std::cout << "First Vert" << std::endl;
	Util::print_vec(first_vert);
	std::cout << "Projected Position" << std::endl;
	Util::print_vec(world_to_view * orientation * first_vert);

	// TODO: Make a prerender function or move this to render
	m_batch.prerender();
}

void MyObjectOrientedScene::render()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	m_shader_program.use();
	glUniformMatrix4fv(6, 1, GL_FALSE, &m_camera.get_world_to_view_matrix()[0][0]);
	m_batch.render();
}

#undef FIRST_VERT