#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include "GL\glew.h"
#include "GL\freeglut.h"
#include "tekstura.h"
#include <fstream>
#include "shaderLoader.h" //narzŕdzie do │adowania i kompilowania shaderˇw z pliku


//funkcje algebry liniowej
#include "glm/vec3.hpp" // glm::vec3
#include "glm/vec4.hpp" // glm::vec4
#include "glm/mat4x4.hpp" // glm::mat4
#include "glm/gtc/matrix_transform.hpp" // glm::translate, glm::rotate, glm::scale, glm::perspective


//Wymiary okna
int screen_width = 640;
int screen_height = 480;


int pozycjaMyszyX; // na ekranie
int pozycjaMyszyY;
int mbutton; // wcisiety klawisz myszy

double kameraX= -30.0;
double kameraZ = 20.0;
double kameraD = -4.0;
double kameraPredkosc;
double kameraKat = 90;
double kameraPredkoscObrotu;
double poprzednie_kameraX;
double poprzednie_kameraZ;
double poprzednie_kameraD;

double rotation = 0;
//do tekstury potrzeba, załadować programID a trianglesID = loadShaders("vertex_shader.glsl", "fragment_shader2.glsl");
//wczytajteksture i setup tekstur
//dodac plik


//macierze
glm::mat4 MV; //modelview - macierz modelu i świata
glm::mat4 P;  //projection - macierz projekcji, czyli naszej perspektywy

//trojkaty
float vertices[] = {
	0.0f, 1.0f, 0.0f,
	0.0f, 0.0f, 0.0f,
	1.0f,  0.0f, 0.0f

};
//trojkatyy
float vertices1[] = {

	0.0f, 1.0f, 0.0f,
	1.0f, 1.0f, 0.0f,
	1.0f,  0.0, 0.0f

};
//prostokąt
float vertices2[] = {
	0.0f, 0.0f, 0.0f,
	0.0f, 0.0f, 2.0f,
	0.0f,  1.0f, 2.0f,
	0.0f,  1.0f, 0.0f
};
//podłoga
float vertices3[] = {
	-5, -1, 5,
	5, -1, 5,
	5, -1, -5,
	-5, -1, -5
};

GLuint elements3[] = {
	0, 1, 2, 3
};

//kostka
/*float vertices4[] = {
	-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
	0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
	0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
	0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
	-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
	-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,

	-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
	0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
	0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
	0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
	-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
	-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,

	-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
	-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
	-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
	-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
	-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
	-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,

	0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
	0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
	0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
	0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
	0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
	0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,

	-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
	0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
	0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
	0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
	-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
	-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,

	-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
	0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
	0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
	0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
	-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
	-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f
}; */

GLfloat vertices4[] = {
	// front
	-1.0, -1.0, 1.0,
	1.0, -1.0, 1.0,
	1.0, 1.0, 1.0,
	-1.0, 1.0, 1.0,
	// back
	-1.0, -1.0, -1.0,
	1.0, -1.0, -1.0,
	1.0, 1.0, -1.0,
	-1.0, 1.0, -1.0
};

GLuint elements4[] = {
	// front colors
	1,0,0,
	0,1,0,
	0,0,1,
	1,1,1,

	1, 0, 0,
	0, 1, 0,
	0, 0, 1,
	1, 1, 1,

};


//unsigned int VBO4, cubeVAO4;


int elements[] = { 0,1,2 };
int elements1[] = {0,1,2};
int elements2[] = {0,1,2,3};

float texCoords[] = {
	0.5, 0,
	1, 1,
	0,1
};

float texCoords1[] = {
	0, 1,
	1,1,
	0.5,0
};

//float texCoords2[] = {
//	0,1,
//	1,1,
//	1,0,
//	0,0
//};


//shaders
GLuint programID = 0;
GLuint trianglesID = 0;

unsigned int VBO;
unsigned int VBO1;
unsigned int VBO2;
unsigned int VBO3;
unsigned int VBO4;

GLuint EBO;
GLuint EBO1;
GLuint EBO2;
GLuint EBO3;
GLuint EBO4;

GLuint VAO[5];

int texid1;
int texid2;

GLuint vtex;
GLuint vtex1;

int sampler_id;
int sampler_id2;



float opacity = 1.0;


/*###############################################################*/
void mysz(int button, int state, int x, int y)
{
	mbutton = button;
	switch (state)
	{
	case GLUT_UP:
		break;
	case GLUT_DOWN:
		pozycjaMyszyX = x;
		pozycjaMyszyY = y;
		poprzednie_kameraX = kameraX;
		poprzednie_kameraZ = kameraZ;
		poprzednie_kameraD = kameraD;
		break;

	}
}
/*******************************************/
void mysz_ruch(int x, int y)
{
	if (mbutton == GLUT_LEFT_BUTTON)
	{
		kameraX = poprzednie_kameraX - (pozycjaMyszyX - x) * 0.1;
		kameraZ = poprzednie_kameraZ - (pozycjaMyszyY - y) * 0.1;
	}
	if (mbutton == GLUT_RIGHT_BUTTON)
	{
		kameraD = poprzednie_kameraD + (pozycjaMyszyY - y) * 0.1;
	}

}
/******************************************/

double dx = 1;

void klawisz(GLubyte key, int x, int y)
{
	switch (key) {

	case 27:    /* Esc - koniec */
		exit(1);
		break;

	case 'x':
		dx += 0.1;
		break;
	case '1':

		break;
	case '2':

		break;
	}


}
/*###############################################################*/
void rysuj(void)
{

	//GLfloat color[] = { 1.0f, 0.0f, 0.0f, 1.0f };
	//glClearBufferfv(GL_COLOR, 0, color);
	glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Kasowanie ekranu

	glUseProgram(programID); //u┐yj programu, czyli naszego shadera

	MV = glm::mat4(1.0f);  //macierz jednostkowa
	MV = glm::translate(MV, glm::vec3(dx, 0, kameraD));
	MV = glm::rotate(MV, (float)glm::radians(kameraZ), glm::vec3(1, 0, 0));
	MV = glm::rotate(MV, (float)glm::radians(kameraX), glm::vec3(0, 1, 0));

	glm::mat4 MVP = P * MV;

	/*Zmienne   jednorodne   (ang. uniform variable), zwane  także  zmiennym  globalnymi,sązmiennymi,
		których  wartośc  jest  stała  w  obrębie  obiektu programu. Shadery  mogą zmienne jednorodne tylko  odczytywac */

	GLuint MVP_id = glGetUniformLocation(programID, "MVP"); // pobierz lokalizację zmiennej 'uniform' "MV" w programie
	glUniformMatrix4fv(MVP_id, 1, GL_FALSE, &(MVP[0][0]));	   // wyślij tablicę mv do lokalizacji "MV", która jest typu mat4

	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);


	//glBindVertexArray(VAO[2]);
	//glVertexAttrib3f(2, 0.75f, 0.0f, 1.0f); //do zmiany koloru
	//glDrawElements(GL_QUADS, 4, GL_UNSIGNED_INT, 0);

	glBindVertexArray( VAO[ 4 ] );
	glVertexAttrib3f( 2, 0.75f, 0.0f, 1.0f ); //do zmiany koloru
	glDrawElements( GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0 );

	//glBindVertexArray( cubeVAO4 );
	//glDrawArrays( GL_TRIANGLES, 0, 36 );




	//do uzycia tekstur
	//glUseProgram(trianglesID);
	//MVP_id = glGetUniformLocation(trianglesID, "MVP"); // pobierz lokalizację zmiennej 'uniform' "MV" w programie
	//glUniformMatrix4fv(MVP_id, 1, GL_FALSE, &(MVP[0][0]));	   // wyślij tablicę mv do lokalizacji "MV", która jest typu mat4

	//glActiveTexture(GL_TEXTURE0);

			//glBindVertexArray(VAO[0]); //bindowanie poszczegolnych figur

			//glVertexAttrib3f(1, 1.0f, 1.0, 0.0f);

	//glBindTexture(GL_TEXTURE_2D,texid1);
	//glUniform1i(sampler_id,0);
			//glDrawElements(GL_TRIANGLES,3,GL_UNSIGNED_INT,0);

	//glActiveTexture(GL_TEXTURE1);

			//glBindVertexArray(VAO[1]);

			//glVertexAttrib3f(2, .0f, 0.0f, 0.0f);

	//glBindTexture(GL_TEXTURE_2D,texid1);
	//glUniform1i(sampler_id,1);

			//glDrawElements(GL_TRIANGLES,3,GL_UNSIGNED_INT,0);


	glFlush();
	glutSwapBuffers();

}
/*###############################################################*/
void rozmiar(int width, int height)
{
	screen_width = width;
	screen_height = height;

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glViewport(0, 0, screen_width, screen_height);

	P = glm::perspective(glm::radians(60.0f), (GLfloat)screen_width / (GLfloat)screen_height, 1.0f, 1000.0f);

	glutPostRedisplay(); // Przerysowanie sceny
}

/*###############################################################*/
void idle()
{

	glutPostRedisplay();
}

/*###############################################################*/
float k = 0.1f;

void timer(int value) {

	opacity -= k;

	if(opacity>1 || opacity<0)
	k=-k;

	//GLfloat attrib[] = { ad, 0.0f,0.0f };
	// Aktualizacja wartości atrybutu wejściowego 1.
	//glVertexAttrib3fv(1, attrib);

	/*

	W vertex_shader np:
	layout (location = 1) in vec3 incolor;

	*/
	glutTimerFunc(25, timer, 0);
}
/*###############################################################*/
int main(int argc, char **argv)
{

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB | GLUT_DEPTH);
	glutInitWindowSize(screen_width, screen_height);
	glutInitWindowPosition(0, 0);
	glutCreateWindow("Kolokwium");

	glewInit(); //init rozszerzeszeń OpenGL z biblioteki GLEW

	glutDisplayFunc(rysuj);			// def. funkcji rysuj¦cej
    glutIdleFunc(idle);			// def. funkcji rysuj¦cej w czasie wolnym procesoora (w efekcie: ci¦gle wykonywanej)
	glutTimerFunc(20, timer, 0);
	glutReshapeFunc(rozmiar); // def. obs-ugi zdarzenia resize (GLUT)

	glutKeyboardFunc(klawisz);		// def. obsługi klawiatury
	glutMouseFunc(mysz); 		// def. obsługi zdarzenia przycisku myszy (GLUT)
	glutMotionFunc(mysz_ruch); // def. obsługi zdarzenia ruchu myszy (GLUT)


	glEnable(GL_DEPTH_TEST);

	//glPointSize(3.0f);


	/* úadowanie shadera, tworzenie programu *************************/
	/* i linkowanie go oraz sprawdzanie b│ŕdˇw! **********************/
	programID = loadShaders("vertex_shader.glsl", "fragment_shader.glsl");
	trianglesID = loadShaders("vertex_shader.glsl", "fragment_shader2.glsl");

	//setup textur
	texid1 = WczytajTeksture("monalisa.bmp");

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, texid1);
	sampler_id = glGetUniformLocation(trianglesID, "texSampler");
	glUniform1i(sampler_id,0);


	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, texid1);
	glUniform1i(sampler_id,1);


	glGenVertexArrays(3,VAO);

	//tworzenie bufora wierzcholków
	///
	glGenBuffers(1,&vtex);
	glBindBuffer(GL_ARRAY_BUFFER, vtex);
	glBufferData(GL_ARRAY_BUFFER, sizeof(texCoords), texCoords, GL_STATIC_DRAW);

	glGenBuffers(1,&vtex1);
	glBindBuffer(GL_ARRAY_BUFFER, vtex1);
	glBufferData(GL_ARRAY_BUFFER, sizeof(texCoords1), texCoords1, GL_STATIC_DRAW);
	///
	glGenBuffers( 1, &VBO4 );
	glBindBuffer( GL_ARRAY_BUFFER, VBO4 );
	glBufferData( GL_ARRAY_BUFFER, sizeof( vertices4 ), vertices4, GL_STATIC_DRAW );

	glGenBuffers( 1, &EBO4 );
	glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, EBO4 );
	glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( elements4 ), elements4, GL_STATIC_DRAW );
	///
	glGenBuffers( 1, &VBO3 );
	glBindBuffer( GL_ARRAY_BUFFER, VBO3 );
	glBufferData( GL_ARRAY_BUFFER, sizeof( vertices3 ), vertices3, GL_STATIC_DRAW );

	glGenBuffers( 1, &EBO3 );
	glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, EBO3 );
	glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( elements3 ), elements3, GL_STATIC_DRAW );
	///
	glGenBuffers(1, &VBO2);
	glBindBuffer(GL_ARRAY_BUFFER, VBO2);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices2), vertices2, GL_STATIC_DRAW);

	glGenBuffers(1,&EBO2);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO2);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(elements2), elements2, GL_STATIC_DRAW);

	///
	glGenBuffers(1, &VBO1);
	glBindBuffer(GL_ARRAY_BUFFER, VBO1);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices1), vertices1, GL_STATIC_DRAW);

	glGenBuffers(1, &EBO1);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO1);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements1), elements1, GL_STATIC_DRAW);

	///
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	glGenBuffers(1,&EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(elements), elements, GL_STATIC_DRAW);


	//VAO
	glBindVertexArray(VAO[0]);

	glBindBuffer(GL_ARRAY_BUFFER, vtex);
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0);

	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0 );

	//VAO1
	glBindVertexArray(VAO[1]);

	glBindBuffer(GL_ARRAY_BUFFER, vtex1);
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0);

	glBindBuffer(GL_ARRAY_BUFFER, VBO1);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO1);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

	//VAO2
	glBindVertexArray(VAO[2]);

	glBindBuffer(GL_ARRAY_BUFFER, VBO2);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO2);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0 );

	//VA03
	glBindVertexArray( VAO[ 3 ] );

	glBindBuffer( GL_ARRAY_BUFFER, VBO3 );
	glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, EBO3 );
	glEnableVertexAttribArray( 0 );
	glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, ( void* )0 );

	//Vao4
	glBindVertexArray( VAO[ 4 ] );

	glBindBuffer( GL_ARRAY_BUFFER, VBO4 );
	glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, EBO4 );
	glEnableVertexAttribArray( 0 );
	glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, ( void* )0 );



	///kostka
		//glGenVertexArrays( 1, &cubeVAO4 );
		//glBindVertexArray( cubeVAO4 );
		//glGenBuffers( 1, &VBO4 );

		//glBindBuffer( GL_ARRAY_BUFFER, VBO4 );
		//glBufferData( GL_ARRAY_BUFFER, sizeof( vertices4 ), vertices4, GL_STATIC_DRAW );

		// position attribute
		//glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof( float ), ( void* )0 );
		//glEnableVertexAttribArray( 0 );
		// normal attribute
		//glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof( float ), ( void* )( 3 * sizeof( float ) ) );
		//glEnableVertexAttribArray( 1 );


	////glBindBuffer(GL_ARRAY_BUFFER, VBO);
	////glEnableVertexAttribArray(0); // pierwszy buform atrybuˇw: wierzcho│ki
	//glVertexAttribPointer(
	//	0,                  // atrybut 0. musi odpowiadaŠ atrybutowi w programie shader
	//	3,                  // wielkoťŠ (x,y,z)
	//	GL_FLOAT,           // typ
	//	GL_FALSE,           // czy znormalizowany [0-1]?
	//	0,                  // stride
	//	(void*)0            // array buffer offset
	//);

	glutMainLoop();					// start

	glDeleteBuffers(1, &VBO);
	glDeleteBuffers(1, &VBO1);
	glDeleteBuffers(1, &VBO2);

	return(0);
}