#include "Dependencies\glew\glew.h"
#include "Dependencies\freeglut\freeglut.h"
#include <iostream>
#include <stdio.h>
#include "Dependencies\glm\glm\ext.hpp"
#include "shader_stuff.h"

#define VERTEX_SHADER_PATH "vertex.glsl"
#define FRAGMENT_SHADER_PATH "fragment.glsl"
#define SCREEN_FPS 60
#define HOUSE_TRIANGLE_N 7


// ---------------------------------------
// Identyfikatory obiektow

GLuint program;
GLuint vBuffer_coord;
GLuint vBuffer_color;
GLuint vBuffer_indices;
GLuint vArray;



GLfloat triangles_cord_compressed[8 * 3] =
{
    // front face points

    // p0
    -0.5, -0.5, 0.5,
    // p1
    0.5, -0.5, 0.5,
    // p2
    0.5, 0.5, 0.5,
    // p3
    -0.5, 0.5, 0.5,

    // back face

    // p4
    -0.5, -0.5, -0.5,
    // p5
    0.5, -0.5, -0.5,
    // p6
    0.5, 0.5, -0.5,
    // p7
    -0.5, 0.5, -0.5,

};
GLfloat triangles_color_compressed[3 * 2 * 6] =
{
    1.f, 0.f, 0.f,
    1.f, 0.f, 0.f,

    0.f, 1.f, 0.f,
    0.f, 1.f, 0.f,

    0.f, 0.f, 1.f,
    0.f, 0.f, 1.f,

    1.f, 1.f, 0.f,
    1.f, 1.f, 0.f,

    0.f, 1.f, 1.f,
    0.f, 1.f, 1.f,

    1.f, 0.f, 1.f,
    1.f, 0.f, 1.f
};

GLuint triangles_indices_compressed[3 * 2 * 6] =
{
    // front face
    0,1,3,
    1,2,3,

    // right face
    1,5,2,
    5,6,2,

    // left face
    4,0,7,
    0,3,7,

    // bottom face
    0,1,4,
    1,5,4,

    // top face
    3,2,7,
    2,6,7,

    // back face
    4,5,7,
    5,6,7

};

// ---------------------------------------
// Macierze przeksztalcen i rzutowania

glm::mat4x4 Matrix_proj;    // projection matrix
glm::mat4x4 Matrix_mv;      // modelview matrix
glm::mat4x4 Matrix_proj_mv; // projection*modelview matrix

// Zmienna kontrolujaca obrot szescianu
GLfloat obrot = 0.0;
// ---------------------------------------
void DisplayScene()
{

    // Czyszczenie ramki
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // ------------------------------
    // 1. Geometria sceny
    // Ustawiamy macierz jednostkowa
    Matrix_mv = glm::mat4x4(1.0);

    // Przesuwamy srodek ukladu o 2 jednostki za ekran (oddalamy)
    Matrix_mv = glm::translate(Matrix_mv, glm::vec3(0.0f, 0.0f, -2.0));

    // Obracamy srodek ukladu
    Matrix_mv = glm::rotate(Matrix_mv, obrot, glm::vec3(0.0f, 1.0f, 0.0f));

    // ------------------------------
    // 2. Obliczenie macierzy rzutowania
    // (wlasciwie mnozenie mogloby sie odbyc w vs, ale...?)

    Matrix_proj_mv = Matrix_proj * Matrix_mv;

    // ------------------------------
    // 3. Przekazanie macierzy do vertex shadera
    glUniformMatrix4fv(glGetUniformLocation(program, "Matrix_proj_mv"), 1, GL_FALSE, glm::value_ptr(Matrix_proj_mv));

    // ------------------------------
    // 4. Generowanie obiektow na ekranie
    glDrawArrays(GL_TRIANGLES, 0, 3*2*6);

    // ------------------------------
    // ZADANIE 1: Wygeneruj kolejny szescian obok/na gorze itp.
    // ZADANIE 2: Spraw aby obracal sie w druga strone bez dodawania zadnej nowej zmiennej

    glutSwapBuffers();
}


// ---------------------------------------
void Reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    //Matrix_proj = glm::frustum( -1.0f, 1.0f, (-1.0f*height)/width, 1.0f*height/width, 1.0f, 4.f );
    Matrix_proj = glm::perspective(glm::radians(90.0f), (float)width / (float)height, 0.1f, 100.f);
}


// ---------------------------------------
void Initialize()
{

    glClearColor(0.5f, 0.5f, 0.5f, 1.0f);


    // 1. Program i shadery
    program = glCreateProgram();

    glAttachShader(program, LoadShader(GL_VERTEX_SHADER, "vertex.glsl"));
    glAttachShader(program, LoadShader(GL_FRAGMENT_SHADER, "fragment.glsl"));

    LinkAndValidateProgram(program);



    // 2. Vertex arrays

#define POSITION 0
#define COLOR 1

    glGenVertexArrays(1, &vArray);
    glBindVertexArray(vArray);

    // BUFOR: Wspolrzedne wierzcholkow

    glGenBuffers(1, &vBuffer_coord);
    glBindBuffer(GL_ARRAY_BUFFER, vBuffer_coord);
    glBufferData(GL_ARRAY_BUFFER, sizeof(triangles_cord_compressed), triangles_cord_compressed, GL_STATIC_DRAW);

    glVertexAttribPointer(POSITION, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(POSITION);

    // BUFOR: Kolor wierzcholkow

    glGenBuffers(1, &vBuffer_color);
    glBindBuffer(GL_ARRAY_BUFFER, vBuffer_color);
    glBufferData(GL_ARRAY_BUFFER, sizeof(triangles_color_compressed), triangles_color_compressed, GL_STATIC_DRAW);

    glVertexAttribPointer(COLOR, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(COLOR);

    // BUFOR: Indeksy wierzcholkow

    glGenBuffers(1, &vBuffer_indices);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vBuffer_indices);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(triangles_indices_compressed), triangles_indices_compressed, GL_STATIC_DRAW);


    glBindVertexArray(0);
    glEnable(GL_DEPTH_TEST);


    // Wlaczenie VA i programu
    glBindVertexArray(vArray);
    glUseProgram(program);
}


// ---------------------------------------------------
void Animation(int frame)
{
    // Obracanie szescianu
    obrot += 0.01f;
    if (obrot > 2 * 3.14f) obrot = 0.f;

    glutPostRedisplay();
    glutTimerFunc(10, Animation, 0);
}

// ---------------------------------------------------
int main(int argc, char* argv[])
{
    // GLUT
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitContextVersion(3, 2);
    glutInitContextProfile(GLUT_CORE_PROFILE);
    glutInitWindowSize(500, 500);
    glutCreateWindow("Tablice wierzcholkow");
    glutDisplayFunc(DisplayScene);
    glutReshapeFunc(Reshape);
    glutTimerFunc(100, Animation, 0);


    // GLEW
    glewExperimental = GL_TRUE;
    GLenum err = glewInit();
    if (GLEW_OK != err)
    {
        printf("GLEW Error\n");
        exit(1);
    }

    // OpenGL
    if (!GLEW_VERSION_3_2)
    {
        printf("Brak OpenGL 3.2!\n");
        exit(1);
    }


    Initialize();


    glutMainLoop();

    // Cleaning
    glDeleteProgram(program);
    glDeleteBuffers(1, &vBuffer_coord);
    glDeleteBuffers(1, &vBuffer_color);
    glDeleteVertexArrays(1, &vArray);

    return 0;
}