/*#ifdef _MSC_VER
#pragma comment(linker, "/SUBSYSTEM:windows /ENTRY:mainCRTStartup")
#endif*/


#include <iostream>
#include <vector>

#include "../lib/glew/GL/glew.h"
#include "../lib/glfw/glfw3.h"
#include "../lib/glm/glm.hpp"
#include "../lib/glm/gtc/matrix_transform.hpp"

#include "vertex.h"
#include "shader.h"
#include "buffer.h"

#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 600

int main() {
	// Initialize OpenGL
	if (!glfwInit()) {
		std::cerr << "Failed to initialize glfw\n";
		return 1;
	}

	glfwWindowHint(GLFW_RESIZABLE, false);
	glfwWindowHint(GLFW_SAMPLES, 8);
	
	//glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	//glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
	//glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	GLFWwindow* win = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Daniel Poveda", nullptr, nullptr);
	if (win == nullptr) {
		std::cerr << "Failed to create opengl window\n";
		glfwTerminate();
		return 1;
	}
	glfwMakeContextCurrent(win);

	glEnable(GL_DEPTH_TEST);
	glEnable(GL_SCISSOR_TEST);

	std::cout << "OpenGL initialized, version: " << glGetString(GL_VERSION) << "\n";

	// Initialize GLEW
	glewExperimental = GL_TRUE;
	GLenum err = glewInit();
	if (err != GLEW_OK) {
		std::cerr << "Failed to initialize GLEW: " << glewGetErrorString(err) << "\n";
		glfwTerminate();
		return 1;
	}

	// Logic
	std::vector<Vertex> vertices = {
		{{0.0f, 0.5f, 0.0f}, {0.0f, 1.0f, 0.0f}},
		{{-0.5f, -0.5f, 0.0f}, {0.0f, 0.0f, 1.0f}},
		{{0.5f, -0.5f, 0.0f}, {1.0f, 0.0f, 0.0f}} 
	};
	std::vector<uint16_t> indices = { 0, 1, 2 };

	Buffer buffer(vertices, indices);
	Shader shader("data/vertex.glsl", "data/fragment.glsl");
	if (std::strlen(shader.getError()) > 0) {
		std::cerr << "Failed to initialize shaders: " << shader.getError() << "\n";
	}

	glm::mat4 projection = glm::perspective(glm::radians(45.0f), static_cast<float>(SCREEN_WIDTH) / SCREEN_HEIGHT, 0.1f, 100.0f);
	//glm::mat4 view = glm::translate(glm::mat4(1.0f), glm::vec3(0, 0, 6));
	glm::mat4 view = glm::lookAt(glm::vec3(0, 0, 6), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));

	// main loop
	double angle = 0.0;
	double lastTime = glfwGetTime();
	while (!glfwWindowShouldClose(win) && !glfwGetKey(win, GLFW_KEY_ESCAPE)) {
		// Delta
		double delta_time = glfwGetTime() - lastTime;
		lastTime = glfwGetTime();

		// Reset window
		int screenWidth, screenHeight;
		glfwGetWindowSize(win, &screenWidth, &screenHeight);
		glViewport(0, 0, screenWidth, screenHeight);

		glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		shader.Use();

		// Logic
		angle += 32.0 * delta_time;

		for (int row = 0; row < 3; ++row) {
			for (int col = 0; col < 3; ++col) {
				glm::mat4 model = glm::translate(glm::mat4(1.0), glm::vec3(-3.0f + static_cast<float>(col) * 3.0f, 0.0f, static_cast<float>(-row) * 3.0f));
				model = glm::rotate(model, glm::radians(static_cast<float>(angle)), glm::vec3(0, 1, 0));

				glm::mat4 mvp = projection * view * model;

				Shader::setMat4(shader.getLocation("mvp"), mvp);

				buffer.Draw(shader);
			}
		}

		// Refresh screen
		glfwSwapBuffers(win);
		glfwPollEvents();
	}

	// Shutdown
	glfwTerminate();

	return 0;
}