#include <iostream>
#include <GL/glew.h>
#include <SFML/Window.hpp>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>


// Kody shaderów
const GLchar* vertexSource = R"glsl(
#version 150 core
in vec3 position;
in vec3 color;
uniform mat4 model;
uniform mat4 view;
uniform mat4 proj;
out vec3 Color;
void main(){

Color = color;

gl_Position = proj * view * model * vec4(position, 1.0);

}
)glsl";

const GLchar* fragmentSource = R"glsl(
#version 150 core
in vec3 Color;
out vec4 outColor;
void main()
{
outColor = vec4(Color, 1.0);
}
)glsl";
//ZMIENNE OPISUJĄCE KAMERE
glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
float obrot = 0;

//



int main()
{
    sf::ContextSettings settings;
    settings.depthBits = 24;
    settings.stencilBits = 8;

    // Okno renderingu
    sf::Window window(sf::VideoMode(800, 600, 32), "OpenGL", sf::Style::Titlebar | sf::Style::Close, settings);

    // Inicjalizacja GLEW
    glewExperimental = GL_TRUE;
    glewInit();

    // Utworzenie VAO (Vertex Array Object)
    GLuint vao;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    // Utworzenie VBO (Vertex Buffer Object)
    // i skopiowanie do niego danych wierzchołkowych
    GLuint vbo;
    glGenBuffers(1, &vbo);



    /*

    ///Zmiana 2) - odwrócony trójkąt
    GLfloat* vertices = new  GLfloat[]{
    -0.5f,  0.5f, 1.0f, 0.0f, 0.0f,// Top-left
     0.5f,  0.5f, 0.0f, 1.0f, 0.0f,// Top-right
     0.5f, -0.5f, 0.0f, 0.0f, 1.0f, // Bottom-right

     0.5f, -0.5f, 0.0f, 0.0f, 1.0f,// Bottom-right
    -0.5f, -0.5f, 1.0f, 1.0f, 1.0f,// Bottom-left
    -0.5f,  0.5f, 1.0f, 0.0f, 0.0f // Top-left

    };
    */
    float vertices[] = {
-0.5f, -0.5f, -0.5f, 0.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, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.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, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.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, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.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, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 1.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, 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, 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, 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, 1.0f, 1.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, 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, 1.0f, 1.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, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f
    };

    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // Utworzenie i skompilowanie shadera wierzchołków
    GLuint vertexShader =
        glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexSource, NULL);
    glCompileShader(vertexShader);

    // Utworzenie i skompilowanie shadera fragmentów
    GLuint fragmentShader =
        glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
    glCompileShader(fragmentShader);

    // Zlinkowanie obu shaderów w jeden wspólny program
    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glBindFragDataLocation(shaderProgram, 0, "outColor");
    glLinkProgram(shaderProgram);
    glUseProgram(shaderProgram);

    // Specifikacja formatu danych wierzchołkowych
    GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
    glEnableVertexAttribArray(posAttrib);
    glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), 0);
    GLint colAttrib = glGetAttribLocation(shaderProgram, "color");
    glEnableVertexAttribArray(colAttrib);

    //3)Zepsuje tutaj w tym miejscu ostatni parametr i program zamiast się wysypać zmieni kolor figury w środku

    glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));

    // Rozpoczęcie pętli zdarzeń
    bool running = true;
    //ZMIANY
    int punkty_ = 6;
    long prymityw = GL_TRIANGLES;
    long double mouse_y = 0;
    //ZMIANY


    /// <summary>
    /// ///
    /// </summary>
    /// <returns></returns>


    glm::mat4 model = glm::mat4(1.0f);

    model = glm::rotate(model, glm::radians(45.0f), glm::vec3(0.0f, 0.0f, 1.0f));

    GLint uniTrans = glGetUniformLocation(shaderProgram, "model");
    glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));

    glm::mat4 view;
    view = glm::lookAt(glm::vec3(0.0f, 0.0f, 3.0f),
        glm::vec3(0.0f, 0.0f, 0.0f),
        glm::vec3(0.0f, 1.0f, 0.0f));

    GLint uniView = glGetUniformLocation(shaderProgram, "view");
    glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
    glm::mat4 proj = glm::perspective(glm::radians(45.0f), 800.0f / 800.0f, 0.06f, 100.0f);
    GLint uniProj = glGetUniformLocation(shaderProgram, "proj");
    glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));

    view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
    float cameraSpeed = 0.1f;
    float obrot = 0.3f;
    while (running) {
        sf::Event windowEvent;
        while (window.pollEvent(windowEvent)) {
            switch (windowEvent.type) {
            case sf::Event::Closed:
                running = false;
                break;

            case sf::Event::KeyPressed:
            {
                switch (windowEvent.key.code)
                {
                case sf::Keyboard::Num1:
                    prymityw = GL_POINTS;
                    break;
                case sf::Keyboard::Num2:
                    prymityw = GL_LINES;
                    break;
                case sf::Keyboard::Num3:
                    prymityw = GL_LINE_STRIP;
                    break;
                case sf::Keyboard::Num4:
                    prymityw = GL_LINE_LOOP;
                    break;
                case sf::Keyboard::Num5:
                    prymityw = GL_TRIANGLES;
                    break;
                case sf::Keyboard::Num6:
                    prymityw = GL_TRIANGLE_STRIP;
                    break;
                case sf::Keyboard::Num7:
                    prymityw = GL_TRIANGLE_FAN;
                    break;
                case sf::Keyboard::Num8:
                    prymityw = GL_QUADS;
                    break;
                case sf::Keyboard::Num9:
                    prymityw = GL_QUAD_STRIP;
                    break;
                case sf::Keyboard::Num0:
                    prymityw = GL_POLYGON;
                    break;


                case sf::Keyboard::W:
                          cameraPos -= cameraSpeed * cameraFront;
                    break;
                case sf::Keyboard::Right:

                      obrot -= cameraSpeed;
                    cameraFront.x = sin(obrot);
                    cameraFront.z = -cos(obrot);


                    break;

                case sf::Keyboard::Left:

                  obrot -= cameraSpeed;
                cameraFront.x = -sin(obrot);
                cameraFront.z = cos(obrot);
                break;



            }

            }
            }
            // Nadanie scenie koloru czarnego
            glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
            glClear(GL_COLOR_BUFFER_BIT);

            // Narysowanie trójkąta na podstawie 3 wierzchołków
            ///Zmiana 2.1 z 3 wierzchołków na 6 wierzchołków
            ///
            //glBindBuffer(GL_ARRAY_BUFFER, buffer);


            glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * punkty_ * 6, vertices,
                GL_STATIC_DRAW);
            glDrawArrays(prymityw, 0, punkty_);
            // Wymiana buforów tylni/przedni
            window.display();
        }
    }
        // Kasowanie programu i czyszczenie buforów
        glDeleteProgram(shaderProgram);
        glDeleteShader(fragmentShader);
        glDeleteShader(vertexShader);
        glDeleteBuffers(1, &vbo);
        glDeleteVertexArrays(1, &vao);
        // Zamknięcie okna renderingu
        window.close();
        return 0;

}