#include <windows.h>
#include <gl/gl.h>
#include "glext.h"
#include "wglext.h"
#include "libs\glm\glm\glm.hpp"
#include "libs\glm\glm\gtc\matrix_transform.hpp"
#include "libs\glm\glm\gtc\type_ptr.hpp"

#pragma comment(lib, "opengl32.lib")


// Function Declarations

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
void EnableOpenGL(HWND hWnd, HDC * hDC, HGLRC * hRC);
void DisableOpenGL(HWND hWnd, HDC hDC, HGLRC hRC);

//opengl Function Pointers
PFNGLCLEARBUFFERFVPROC  glClearBufferfv;
PFNGLCREATESHADERPROC glCreateShader;
PFNGLSHADERSOURCEPROC glShaderSource;
PFNGLCOMPILESHADERPROC glCompileShader;
PFNGLCREATEPROGRAMPROC glCreateProgram;
PFNGLATTACHSHADERPROC glAttachShader;
PFNGLLINKPROGRAMPROC glLinkProgram;
PFNGLDELETESHADERPROC glDeleteShader;
PFNGLDELETEVERTEXARRAYSPROC glCreateVertexArrays;
PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
PFNGLUSEPROGRAMPROC glUseProgram;
PFNGLDELETEBUFFERSPROC glCreateBuffers;
PFNGLBINDBUFFERPROC glBindBuffer;
PFNGLBUFFERSTORAGEPROC glBufferStorage;
PFNGLNAMEDBUFFERSTORAGEEXTPROC glNamedBufferStorage;
PFNGLBUFFERSUBDATAPROC glBufferSubData;
PFNGLNAMEDBUFFERSUBDATAEXTPROC glNamedBufferSubData;
PFNGLMAPBUFFERPROC glMapBuffer;
PFNGLMAPNAMEDBUFFEREXTPROC glMapNamedBuffer;
PFNGLUNMAPBUFFERPROC glUnmapBuffer;
PFNGLUNMAPNAMEDBUFFEREXTPROC glUnmapNamedBuffer;
PFNGLMAPBUFFERRANGEPROC glMapBufferRange;
PFNGLMAPNAMEDBUFFERRANGEEXTPROC glMapNamedBufferRange;
PFNGLCLEARBUFFERSUBDATAPROC glClearBufferSubData;
PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC glClearNamedBufferSubData;
PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC glVertexArrayAttribFormat;
PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC glVertexArrayVertexBuffer;
PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
PFNGLENABLEVERTEXARRAYATTRIBEXTPROC glEnableVertexArrayAttrib;
PFNGLCLEARBUFFERFIPROC glClearBufferfi;
PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
PFNGLGETSHADERIVPROC glGetShaderiv;
PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;

GLuint program;
GLuint vertexShader;
GLuint fragmentShader;
GLuint buffer;
GLuint vertexArrayObject;

GLint projectionMatrixLocation;
GLint modelViewMatrixLocation;
glm::mat4 projectionMatrix;
glm::mat4 modelViewMatrix;




// WinMain

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
				   LPSTR lpCmdLine, int iCmdShow)
{
	WNDCLASS wc;
	HWND hWnd;
	HDC hDC;
	HGLRC hRC;
	MSG msg;
	BOOL quit = FALSE;
	float theta = 0.0f;

	// register window class
	wc.style = CS_OWNDC;
	wc.lpfnWndProc = WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon( NULL, IDI_APPLICATION );
	wc.hCursor = LoadCursor( NULL, IDC_ARROW );
	wc.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );
	wc.lpszMenuName = NULL;
	wc.lpszClassName = "GLSample";
	RegisterClass( &wc );

	// create main window
	hWnd = CreateWindow(
		"GLSample", "OpenGL Sample",
		WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE,
		0, 0, 256, 256,
		NULL, NULL, hInstance, NULL );

	// enable OpenGL for the window
	EnableOpenGL( hWnd, &hDC, &hRC );

	// program main loop
	while ( !quit )
	{

		// check for messages
		if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE )  )
		{

			// handle or dispatch messages
			if ( msg.message == WM_QUIT )
			{
				quit = TRUE;
			}
			else
			{
				TranslateMessage( &msg );
				DispatchMessage( &msg );
			}

		}
		else
		{



		}

	}

	// shutdown OpenGL
	DisableOpenGL( hWnd, hDC, hRC );

	// destroy the window explicitly
	DestroyWindow( hWnd );

	return msg.wParam;

}

// Window Procedure

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{

	switch (message)
	{

	case WM_CREATE:
		return 0;

	case WM_CLOSE:
		PostQuitMessage( 0 );
		return 0;

	case WM_DESTROY:
		return 0;

	case WM_KEYDOWN:
		switch ( wParam )
		{

		case VK_ESCAPE:
			PostQuitMessage(0);
			return 0;

		}
		return 0;

	default:
		return DefWindowProc( hWnd, message, wParam, lParam );

	}

}

// Enable OpenGL

void EnableOpenGL(HWND hWnd, HDC * hDC, HGLRC * hRC)
{
	PIXELFORMATDESCRIPTOR pfd;
	int format;

	// get the device context (DC)
	*hDC = GetDC( hWnd );

	// set the pixel format for the DC
	ZeroMemory( &pfd, sizeof( pfd ) );
	pfd.nSize = sizeof( pfd );
	pfd.nVersion = 1;
	pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
	pfd.iPixelType = PFD_TYPE_RGBA;
	pfd.cColorBits = 24;
	pfd.cDepthBits = 16;
	pfd.iLayerType = PFD_MAIN_PLANE;
	format = ChoosePixelFormat( *hDC, &pfd );
	SetPixelFormat( *hDC, format, &pfd );

	// create and enable the render context (RC)
	*hRC = wglCreateContext( *hDC );
	wglMakeCurrent( *hDC, *hRC );


	//load opengl Functions
	glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)wglGetProcAddress("glClearBufferfv");
	glCreateShader = (PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader");
	glShaderSource = (PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource");
	glCompileShader = (PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader");
	glCreateProgram = (PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram");
	glAttachShader = (PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader");
	glLinkProgram = (PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram");
	glDeleteShader = (PFNGLDELETESHADERPROC)wglGetProcAddress("glDeleteShader");
	glCreateVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)wglGetProcAddress("glCreateVertexArrays");
	glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)wglGetProcAddress("glBindVertexArray");
	glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)wglGetProcAddress("glDeleteVertexArrays");
	glUseProgram = (PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram");
	glCreateBuffers = (PFNGLDELETEBUFFERSPROC)wglGetProcAddress("glCreateBuffers");
	glBindBuffer = (PFNGLBINDBUFFERPROC)wglGetProcAddress("glBindBuffer");
	glBufferStorage = (PFNGLBUFFERSTORAGEPROC)wglGetProcAddress("glBufferStorage");
	glNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGEEXTPROC)wglGetProcAddress("glNamedBufferStorage");
	glBufferSubData = (PFNGLBUFFERSUBDATAPROC)wglGetProcAddress("glBufferSubData");
	glNamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)wglGetProcAddress("glNamedBufferSubData");
	glMapBuffer = (PFNGLMAPBUFFERPROC)wglGetProcAddress("glMapBuffer");
	glMapNamedBuffer = (PFNGLMAPNAMEDBUFFEREXTPROC)wglGetProcAddress("glMapNamedBuffer");
	glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)wglGetProcAddress("glUnmapBuffer");
	glUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFEREXTPROC)wglGetProcAddress("glUnmapNamedBuffer");
	glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)wglGetProcAddress("glMapBufferRange");
	glMapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC)wglGetProcAddress("glMapNamedBufferRange");
	glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)wglGetProcAddress("glClearBufferSubData");
	glClearNamedBufferSubData = (PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC)wglGetProcAddress("glClearNamedBufferSubData");
	glVertexArrayAttribFormat = (PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC)wglGetProcAddress("glVertexArrayAttribFormat");
	glVertexArrayVertexBuffer = (PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC)wglGetProcAddress("glVertexArrayVertexBuffer");
	glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)wglGetProcAddress("glGenVertexArrays");
	glEnableVertexArrayAttrib = (PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)wglGetProcAddress("glEnableVertexArrayAttrib");
	glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)wglGetProcAddress("glClearBufferfi");
	glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)wglGetProcAddress("glUniformMatrix4fv");
	glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)wglGetProcAddress("glGetUniformLocation");
	glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)wglGetProcAddress("glVertexAttribPointer");
	glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)wglGetProcAddress("glEnableVertexAttribArray");
	glGetShaderiv = (PFNGLGETSHADERIVPROC)wglGetProcAddress("glGetShaderiv");
	glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)wglGetProcAddress("glGetShaderInfoLog");


	//creating program and shaders, compiling shaders, compiling program
	GLchar * v_Shader[] = {


		"#version 410 core                                                  \n"
		"                                                                   \n"
		"in vec4 position;                                                  \n"
		"                                                                   \n"
		"                                                                   \n"
		"uniform mat4 mvmatrix;                                             \n"
		"uniform mat4 projmatrix;                                           \n"
		"                                                                   \n"
		"void main(void)                                                    \n"
		"{                                                                  \n"
		"    gl_Position = projmatrix * mvmatrix * position;                \n"
		"}                                                                  \n"
	};

	GLchar * f_Shader[] = {
		"#version 410 core                                                  \n"
		"                                                                   \n"
		"out vec4 color;                                                    \n"
		"                                                                   \n"
		"in VS_OUT                                                          \n"
		"{                                                                  \n"
		"    vec4 color;                                                    \n"
		"} fs_in;                                                           \n"
		"                                                                   \n"
		"void main(void)                                                    \n"
		"{                                                                  \n"
		"    color = vec4(1.0,1.0,1.0,1.0)                                  \n"
		"}                                                                  \n"
	};

	//creating a opengl program
	program = glCreateProgram();

	//creating the vertex shader and compiling it
	vertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShader, 1, v_Shader, NULL);
	glCompileShader(vertexShader);

	//creating the fragment shader and compiling it
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShader, 1, f_Shader, NULL);
	glCompileShader(fragmentShader);

	//attaching the shaders to the program and linking the program
	glAttachShader(program, vertexShader);
	glAttachShader(program, fragmentShader);
	glLinkProgram(program);
	glUseProgram(program);
	//getting the program's uniform locations
	modelViewMatrixLocation = glGetUniformLocation(program, "mvmatrix");
	projectionMatrixLocation = glGetUniformLocation(program, "projmatrix");




}

// Disable OpenGL

void DisableOpenGL(HWND hWnd, HDC hDC, HGLRC hRC)
{
	wglMakeCurrent( NULL, NULL );
	wglDeleteContext( hRC );
	ReleaseDC( hWnd, hDC );
}