#include "renderer.hpp"
#include <iostream>
#include "rms.hpp"

void GLAPIENTRY MessageCallback( GLenum source,
                 GLenum type,
                 GLuint id,
                 GLenum severity,
                 GLsizei length,
                 const GLchar* message,
                 const void* userParam )
{
  std::cerr << "GL CALLBACK" <<
		  (type == GL_DEBUG_TYPE_ERROR ? "(ERROR):" : "(UNKNOWN):") <<
				  " type="<< std::showbase << std::hex << type <<
				  " severity="<< severity << " message=" << message << std::endl;


}

Renderer::Renderer(short width,short height, std::string shader_name):
		Width(width),Height(height), ClockStart(steady_clock::now()),
		CurrentShader(shader_name),
		Context(nullptr){
	// Init OpenGl
	glewInit();
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);
	glEnable              ( GL_DEBUG_OUTPUT );
	glDebugMessageCallback( MessageCallback, 0 );

	// Create screen quad
	glGenVertexArrays(1,&VAO);
	glBindVertexArray(VAO);
	GLuint vertexbuffer;
	glGenBuffers(1, &vertexbuffer);
	glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
	float square[]{
			-1,1,0,1,1,0,-1,-1,0,
			-1,-1,0,1,1,0,1,-1,0
	};
	glBufferData(GL_ARRAY_BUFFER, 6*3*sizeof(float), square, GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)0);
	glBindVertexArray(0);
	LoadShader();
}

Renderer::~Renderer(){
	glDeleteProgram(RayMarchingShader);
	glDeleteVertexArrays(1,&VAO);
}

void Renderer::Render(){
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// Setup shader
	glUseProgram(RayMarchingShader);
	MProjection=glm::ortho(-10.0f,10.0f,-10.0f,10.0f,0.f,100.0f);
	MModel=glm::scale(glm::mat4(1.0f),glm::vec3(10,10,1));
	glUniformMatrix4fv(UProjection, 1, GL_FALSE, &MProjection[0][0]);
	glUniformMatrix4fv(UModel, 1, GL_FALSE, &MModel[0][0]);
	ClockCurrent = std::chrono::steady_clock::now();
	duration<double> time_span = duration_cast<duration<double>>(ClockCurrent - ClockStart);
	glUniform1f(UTime, time_span.count());
	glUniform2f(UResolution,Width,Height);

	// Draw the actual shader onto the quad
	glBindVertexArray(VAO);
	glDrawArrays(GL_TRIANGLES,0,6);
	glBindVertexArray(0);
	glUseProgram(0);
}

void Renderer::ChangeShader(std::string name){
	this->CurrentShader=name;
	glDeleteProgram(RayMarchingShader);
	LoadShader();
}

void Renderer::RefreshShader(){
	glDeleteProgram(RayMarchingShader);
	LoadShader();
}

void Renderer::LoadShader(){
	RefreshHUD();
	RayMarchingShader = CompileShader(CurrentShader);
	UProjection = glGetUniformLocation(RayMarchingShader, "projection");
	UModel = glGetUniformLocation(RayMarchingShader, "model");
	UResolution = glGetUniformLocation(RayMarchingShader, "resolution");
	UTime = glGetUniformLocation(RayMarchingShader, "time");
}

void Renderer::AjustViewport(short width,short height){
	glViewport(0, 0, width,height);
	this->Width=width;
	this->Height=height;
}

void Renderer::RefreshHUD(){
	USE_CONTEXT(hud.m_Context->current_shader = CurrentShader)
}