#include "OpenGLController.h"
#include "callback.h"
#include "shader.hpp"
#include "Texture.h"
#include <Windows.h>
#include <string>
#include <glm\gtc\matrix_transform.hpp>


#define VERTEX_SHADER "Shader/TextureShader.vert"
#define FRAGMENT_SHADER "Shader/TextureShader.frag"

/////////////////////////////////////////////////////////////////////////
// public constructor/destructor

OpenGLController* OpenGLController::getInstance(int oglMajor, int oglMinor)
{
	static OpenGLController *instace = new OpenGLController(oglMajor, oglMinor);
	return instace;
}

OpenGLController::~OpenGLController()
{
	glDeleteBuffers(1, &gluiVertexBufferID);
	glDeleteVertexArrays(1, &gluiVertexArrayID);
	glDeleteProgram(gluiShaderPrgmID);

	glDeleteTextures(1, &gluiSamplerID);
	glfwTerminate();

	deleteVectors();
}


/////////////////////////////////////////////////////////////////////////
// private constructor

OpenGLController::OpenGLController(int oglMajor, int oglMinor)
{
	// adjust ogl version optional
	iOglMajorVersion = oglMajor;
	iOglMinorVersion = oglMinor;

	// run OGL
	processInit();
}

/////////////////////////////////////////////////////////////////////////
// private functions

void OpenGLController::processInit()
{
	startGLFW();
	createWindow();
	startGLEW();
	setCallbackFunctions();
	
	// set background color
	glClearColor(0.5000f, 0.8000f, 1.0000f, 0.0000f);

	// enable z-order
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);

	// draw vertics only from one side
	glEnable(GL_CULL_FACE);

	// generate stuff
	glGenVertexArrays(1, &gluiVertexArrayID);
	glBindVertexArray(gluiVertexArrayID);

	glGenBuffers(1, &gluiVertexBufferID);

	// open attribute position
	glBindBuffer(GL_ARRAY_BUFFER, gluiVertexBufferID);
	glVertexAttribPointer(VERTEX_INDEX_XYZ, VERTEX_COMPONENTS_XYZ, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)VERTEX_OFFSET_XYZ);
	glVertexAttribPointer(VERTEX_INDEX_UV, VERTEX_COMPONENTS_UV, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)VERTEX_OFFSET_UV);
	glBindBuffer(GL_ARRAY_BUFFER, 0);

	// enable position, UV and mvp
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);

	// get the painter ready
	try
	{
		gluiShaderPrgmID = LoadShaders(VERTEX_SHADER, FRAGMENT_SHADER);
	}
	catch (std::invalid_argument e)
	{
		MessageBox(NULL, e.what(), "MeshViewer 2.0 Error", MB_OK | MB_ICONERROR);
		exit(1);
	}

	// get some shader IDs
	gluiMatrixID = glGetUniformLocation(gluiShaderPrgmID, "MVP");
	gluiSamplerID = glGetUniformLocation(gluiShaderPrgmID, "textureSampler");

	// generate texture
	glGenTextures(1, &gluiTextureID);
	glBindTexture(GL_TEXTURE_2D, gluiTextureID);

	// set some texture parameters
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
}

void OpenGLController::deleteVectors()
{
	while (!vModels.empty())
	{
		Modl* cursor = vModels.back();
		vModels.pop_back();

		while (!cursor->segmLst.empty())
		{
			Segment* segmCuror = cursor->segmLst.back();
			cursor->segmLst.pop_back();

			delete segmCuror->uv;
			delete segmCuror->mesh;
			delete segmCuror->vertex;
			delete segmCuror;
		}
		
		delete cursor;
	}

	while (!vTextures.empty())
	{
		textureData* cursor = vTextures.back();
		vTextures.pop_back();
		delete cursor->data;
		delete cursor;
	}
}

void OpenGLController::startGLFW()
{
	if (!glfwInit())
	{
		MessageBox(NULL, "Failed to initialize GLFW", "MeshViewer 2.0 Error", MB_OK | MB_ICONERROR);
		exit(0);
	}

	glfwWindowHint(GLFW_SAMPLES, iAntiAliasingLevel);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, iOglMajorVersion);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, iOglMinorVersion);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
}

void OpenGLController::createWindow()
{
	pWindow = glfwCreateWindow(iWidth, iHeight, sWindowName.c_str(), NULL, NULL);

	if (pWindow == NULL)
	{
		std::string message = "Your GPU does not support OpenGL ";
		message += std::to_string(iOglMajorVersion);
		message += ".";
		message += std::to_string(iOglMinorVersion);
		message += "\nTry to use an other version";

		MessageBox(NULL, message.c_str(), "MeshViewer 2.0 Error", MB_OK | MB_ICONERROR);

		glfwTerminate();
		exit(0);
	}

	glfwSetWindowUserPointer(pWindow, this);
	glfwMakeContextCurrent(pWindow);
}

void OpenGLController::startGLEW()
{
	glewExperimental = true;

	if (glewInit() != GLEW_OK)
	{
		MessageBox(NULL, "Failed to initialize GLEW", "MeshViewer 2.0 Error", MB_OK | MB_ICONERROR);
		glfwTerminate();
		exit(0);
	}
}

void OpenGLController::setCallbackFunctions()
{
	glfwSetMouseButtonCallback(pWindow, mouseButton);
	glfwSetCursorPosCallback(pWindow, mouseMove);
	glfwSetWindowSizeCallback(pWindow, windowResize);
	glfwSetScrollCallback(pWindow, mouseWheel);
	glfwSetKeyCallback(pWindow, keyPress);
	glfwSetDropCallback(pWindow, dragNdrop);
}

glm::mat4 OpenGLController::getModelMatrix(unsigned int index)
{
	glm::mat4 tempParentMatrix = glm::mat4(1.0f);

	for (unsigned int loop = 0; loop < vModels.size(); loop++)
	{
		if (!strcmp(vModels[index]->parent.c_str(), vModels[loop]->name.c_str()))
		{
			tempParentMatrix = getModelMatrix(loop);
			break;
		}
	}

	return tempParentMatrix * vModels[index]->m4x4Translation;
}

glm::mat4 OpenGLController::getMVPMatrix(unsigned int index)
{
	// Projection
	glm::mat4 m4x4Projection = glm::perspective(fFOV, float(iWidth) / float(iHeight), fMinView, fMaxView);
	
	// View
	glm::mat4 m4x4View = glm::lookAt(
		glm::vec3(dTranslationX, dTranslationY, dTranslationZ),
		glm::vec3(dTranslationX, dTranslationY, dTranslationZ - 1),
		glm::vec3(0, 1, 0)
	);

	// User controlled rotation
	glm::mat4 m4x4ModelRot = glm::mat4(1.0f);
	m4x4ModelRot = glm::rotate(m4x4ModelRot, fRotationX, glm::vec3(1, 0, 0));
	m4x4ModelRot = glm::rotate(m4x4ModelRot, fRotationY, glm::vec3(0, 1, 0));
	m4x4ModelRot = glm::rotate(m4x4ModelRot, fRotationZ, glm::vec3(0, 0, 1));

	// Return MVP
	return m4x4Projection * m4x4View * m4x4ModelRot * getModelMatrix(index);
}


/////////////////////////////////////////////////////////////////////////
// public getter

GLFWwindow * OpenGLController::getWindow() const
{
	return pWindow;
}


/////////////////////////////////////////////////////////////////////////
// public functions

void OpenGLController::resize(int width, int height)
{
	iWidth = width;
	iHeight = height;
}

void OpenGLController::addRotX(float value)
{
	fRotationX += value;
}

void OpenGLController::addRotY(float value)
{
	fRotationY += value;
}

void OpenGLController::addTransX(double value)
{
	dTranslationX += value;
}

void OpenGLController::addTransY(double value)
{
	dTranslationY += value;
}

void OpenGLController::addTransZ(double value)
{
	dTranslationZ += value;
}

void OpenGLController::resetView()
{
	dTranslationX = 0;
	dTranslationY = 0;
	dTranslationZ = 5;
	fRotationX = 0;
	fRotationY = 0;
	fRotationZ = 0;
}

void OpenGLController::updateScene()
{
	// get new matrices
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// use shader prgm
	glUseProgram(gluiShaderPrgmID);

	// bind texture in texture unit 0
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, gluiTextureID);
	// tell sampler to use texture unit 0
	glUniform1i(gluiSamplerID, 0);

	int instanceOffset(0);
	int textureIndex(0);

	for (unsigned int modelIndex = 0; modelIndex < vModels.size(); modelIndex++)
	{
		// skip null, bones, shadowMesh, hidden things (don't increase textrue index!!)
		if (vModels[modelIndex]->type == null ||
			vModels[modelIndex]->type == bone ||
			vModels[modelIndex]->type == shadowMesh ||
			vModels[modelIndex]->renderFlags == 1)
			continue;

		for (auto& segIt : vModels[modelIndex]->segmLst)
		{
			// give texture to the shader
			glTexImage2D(
				GL_TEXTURE_2D,
				0,
				vTextures[textureIndex]->alpha ? GL_RGBA : GL_RGB,
				vTextures[textureIndex]->width,
				vTextures[textureIndex]->height,
				0,
				vTextures[textureIndex]->alpha ? GL_BGRA : GL_BGR,
				GL_UNSIGNED_BYTE,
				vTextures[textureIndex]->data->data()
			);

			glGenerateMipmap(GL_TEXTURE_2D);

			// give the MVP to the shader
			glUniformMatrix4fv(gluiMatrixID, 1, GL_FALSE, &getMVPMatrix(modelIndex)[0][0]);

			glDrawArrays(GL_TRIANGLES, instanceOffset, segIt->meshSize);

			// recalulate counter
			instanceOffset += segIt->meshSize;
			textureIndex++;
		}
	}

	glfwSwapBuffers(pWindow);
	glfwPollEvents();
}

void OpenGLController::loadMsh(const char * path)
{
	// clean up old stuff first
	deleteVectors();

	// get all models
	try
	{
		Object obj(path);
		vModels = obj.getModels();
	}
	catch (std::invalid_argument e)
	{
		MessageBox(NULL, e.what(), "MeshViewer 2.0 Error", MB_OK | MB_ICONERROR);
		return; exit(1);
	}

	// collect vertex data of all models
	std::vector<Vertex> tempBufferData;

	for (auto& modIt : vModels)
	{
		// don't draw bones, nulls, shadow mesh and hidden things
		if (modIt->type == null || modIt->type == bone || modIt->type == shadowMesh || modIt->renderFlags == 1)
			continue;

		for (auto& segIt : modIt->segmLst)
		{
			for (unsigned int i = 0; i < segIt->meshSize; i++)
			{
				Vertex tempVertex;
				tempVertex.position[0] = (GLfloat)segIt->vertex[segIt->mesh[i] * 3];
				tempVertex.position[1] = (GLfloat)segIt->vertex[segIt->mesh[i] * 3 + 1];
				tempVertex.position[2] = (GLfloat)segIt->vertex[segIt->mesh[i] * 3 + 2];

				if (segIt->uv == NULL)
				{
					tempVertex.uv[0] = 1.0;
					tempVertex.uv[1] = 1.0;
				}
				else
				{
					tempVertex.uv[0] = (GLfloat)segIt->uv[segIt->mesh[i] * 2];
					tempVertex.uv[1] = (GLfloat)segIt->uv[segIt->mesh[i] * 2 + 1];
				}

				tempBufferData.push_back(tempVertex);
			}
		}
	}

	// fill the buffer
	glBindBuffer(GL_ARRAY_BUFFER, gluiVertexBufferID);
	glBufferData(
		GL_ARRAY_BUFFER,
		sizeof(Vertex) * tempBufferData.size(),
		tempBufferData.data(),
		GL_STATIC_DRAW
	);
	glBindBuffer(GL_ARRAY_BUFFER, 0);


	// get textures
	for (auto& modIt : vModels)
	{
		// we don't need textures from null, bones, shadowMesh and hidden things, since they are not displayed
		if (modIt->type == null || modIt->type == bone || modIt->type == shadowMesh || modIt->renderFlags == 1)
			continue;
		for (auto& segIt : modIt->segmLst)
		{
			textureData* tempData = new textureData;
			try
			{
				if (segIt->texture == "")
					throw std::invalid_argument("no texture name");

				std::string tempPath = path;

				while (tempPath.back() != '/' && tempPath.back() != '\\')
					tempPath.pop_back();

				TextureTGA tempTex(std::string(tempPath + segIt->texture).c_str());

				tempData->alpha = tempTex.hasAlpha();
				tempData->width = tempTex.getWidth();
				tempData->height = tempTex.getHeight();
				tempData->data = new std::vector<std::uint8_t>(tempTex.getData());
			}
			catch (std::invalid_argument e)
			{
				GLubyte solidColor[4] = { 0, 0, 255, 255 };
				tempData->alpha = true;
				tempData->width = 1;
				tempData->height = 1;
				tempData->data = new std::vector<std::uint8_t>({ 0, 0, 255, 255 });
			}

			vTextures.push_back(tempData);
		}
	}
}