#include <iostream>
#include "imgui.h"
#include "imgui_impl_glfw.h"
#include "imgui_impl_opengl3.h"
#include "glm/glm.hpp"
#include <stdio.h>
#include <vector>
#include <memory>
#if defined(IMGUI_IMPL_OPENGL_LOADER_GL3W)
#include <GL/gl3w.h>    // Initialize with gl3wInit()
#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLEW)
#include <GL/glew.h>    // Initialize with glewInit()
#elif defined(IMGUI_IMPL_OPENGL_LOADER_GLAD)
#include <glad/glad.h>  // Initialize with gladLoadGL()
#else
#include IMGUI_IMPL_OPENGL_LOADER_CUSTOM
#endif

#include <GLFW/glfw3.h>



//nasze wierzcholki
std::vector<glm::fvec3> pointVector;
//do naszej rekursji
int prevIterationCount = 0;
//pozycja intow w pamieci
unsigned int VBO, VAO, EBO;


void processInput(GLFWwindow *window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    glViewport(0, 0, width, height);
}



//odleglosc
float Distance(float x1, float x2, float y1, float y2)
{
    return sqrtf((x2 - x1)*(x2 - x1)+(y2 - y1)*(y2 - y1));
}

//
//DYWAN
//
static void Carpet(int step, GLfloat maxX, GLfloat maxY, GLfloat minX, GLfloat minY, GLuint &VBO, GLuint &VAO, GLuint &program, GLuint &program2)
{
    if (step == 0)
        return;

    GLfloat white[] = {
            minX, maxY, 0.0f,
            maxX, maxY, 0.0f,
            maxX, minY, 0.0f,
            minX, maxY, 0.0f,
            minX, minY, 0.0f,
            maxX, minY, 0.0f
    };
    GLfloat black[] = {
            minX + (maxX - minX)*(1.0f / 3.0f), minY + (maxY - minY)*(2.0f / 3.0f), 0.0f,
            minX + (maxX - minX)*(2.0f / 3.0f), minY + (maxY - minY)*(2.0f / 3.0f), 0.0f,
            minX + (maxX - minX)*(2.0f / 3.0f), minY + (maxY - minY)*(1.0f / 3.0f), 0.0f,
            minX + (maxX - minX)*(1.0f / 3.0f), minY + (maxY - minY)*(2.0f / 3.0f), 0.0f,
            minX + (maxX - minX)*(1.0f / 3.0f), minY + (maxY - minY)*(1.0f / 3.0f), 0.0f,
            minX + (maxX - minX)*(2.0f / 3.0f), minY + (maxY - minY)*(1.0f / 3.0f), 0.0f
    };

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(white), white, GL_DYNAMIC_DRAW);

    glUseProgram(program);
    glBindVertexArray(VAO);
    glDrawArrays(GL_TRIANGLES, 0, 6);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(black), black, GL_DYNAMIC_DRAW);

    glUseProgram(program2);
    glBindVertexArray(VAO);
    glDrawArrays(GL_TRIANGLES, 0, 6);

    Carpet(step-1, minX + (maxX - minX)*(1.0f / 3.0f), maxY, minX, minY + (maxY - minY)*(2.0f / 3.0f), VBO, VAO, program, program2);                                        //TOP LEFT
    Carpet(step-1, minX + (maxX - minX)*(2.0f / 3.0f), maxY, minX + (maxX - minX)*(1.0f / 3.0f), minY + (maxY - minY)*(2.0f / 3.0f), VBO, VAO, program, program2);          //TOP CENTER
    Carpet(step-1, maxX, maxY, minX + (maxX - minX)*(2.0f / 3.0f), minY + (maxY - minY)*(2.0f / 3.0f), VBO, VAO, program, program2);                                        //TOP RIGHT
    Carpet(step-1, minX + (maxX - minX)*(1.0f / 3.0f), minY + (maxY - minY)*(2.0f / 3.0f), minX, minY + (maxY - minY)*(1.0f / 3.0f), VBO, VAO, program, program2);          //CENTER LEFT
    Carpet(step-1, maxX, minY + (maxY - minY)*(2.0f / 3.0f), minX + (maxX - minX)*(2.0f / 3.0f), minY + (maxY - minY)*(1.0f / 3.0f), VBO, VAO, program, program2);          //CENTER RIGHT
    Carpet(step-1, minX + (maxX - minX)*(1.0f / 3.0f), minY + (maxY - minY)*(1.0f / 3.0f), minX, minY, VBO, VAO, program, program2);                                        //BOTTOM LEFT
    Carpet(step-1, minX + (maxX - minX)*(2.0f / 3.0f), minY + (maxY - minY)*(1.0f / 3.0f), minX + (maxX - minX)*(1.0f / 3.0f), minY, VBO, VAO, program, program2);          //BOTTOM CENTER
    Carpet(step-1, maxX, minY + (maxY - minY)*(1.0f / 3.0f), minX + (maxX - minX)*(2.0f / 3.0f), minY, VBO, VAO, program, program2);                                        //BOTTOM RIGHT
}

int main(){
    const char* glsl_version = "#version 330";
    // glfw: initializacja
    // ------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);


    GLFWwindow* window = glfwCreateWindow(900, 900, "Dywan Sierpińskiego", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Nie udało sie stworzyc okna" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Blad inicjalizacji GLADA" << std::endl;
        return -1;
    }
    // Ustawieni ImGui
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO& io = ImGui::GetIO(); (void)io;
    //io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;  // Enable Keyboard Controls
    //io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;   // Enable Gamepad Controls

    ImGui_ImplGlfw_InitForOpenGL(window, true);
    ImGui_ImplOpenGL3_Init(glsl_version);
    ImGui::StyleColorsClassic();
    const char *vertexShaderSource = "#version 330 core\n"
                                     "layout (location = 0) in vec3 aPos;\n"
                                     "void main()\n"
                                     "{\n"
                                     "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
                                     "}\0";
    const char *fragmentShaderSource = "#version 330 core\n"
                                       "out vec4 FragColor;\n"
                                       "void main()\n"
                                       "{\n"
                                       "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
                                       "}\n\0";
    const char *fragmentShaderSource2 = "#version 330 core\n"
                                        "out vec4 FragColor;\n"
                                        "void main()\n"
                                        "{\n"
                                        "   FragColor = vec4(0.0f, 0.0f, 0.0f, 1.0f);\n"
                                        "}\n\0";

    //shadery bez sprwadzenia
    GLuint vertexShader, fragmentShader, fragmentShader2;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);

    // fragment shader
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    fragmentShader2 = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader2, 1, &fragmentShaderSource2, NULL);
    // link shaders
    GLuint shaderProgram, shaderProgram2;
    shaderProgram = glCreateProgram();
    shaderProgram2 = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    glAttachShader(shaderProgram2, vertexShader);
    glAttachShader(shaderProgram2, fragmentShader2);
    glLinkProgram(shaderProgram2);

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    glDeleteShader(fragmentShader2);
    /// te te vbo


    float vertices[] = {
            1, 1, 0.0f,
            1, 0, 0.0f,
            0, 0, 0.0f,
            0, 0, 0.0f,
            0, 1, 0.0f,
            1, 1, 0.0f,  // Lewy górny
};

    /*GLuint indices[] = { // Zauważ, że zaczynamy od 0!
            0, 1, 3, // Pierwszy trójkąt
            1, 2, 3 // Drugi trójkąt
    };*/
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    //glGenBuffers(1, &EBO);
    glBindVertexArray(VAO);
    //glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    //skopiuj naszą tablicę indeksów do EBO
    //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    //glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    //ustaw wskaźniki do atrybutów wierzchołków
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);



    while (!glfwWindowShouldClose(window))
    {
        // input
        // -----
        glfwPollEvents();


        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplGlfw_NewFrame();
        ImGui::NewFrame();

        static int f = 1;
        ImGui::Begin("Opcje");                                              // Create a window called "Options" and append into it.
        ImGui::Text("Ilosc iteracji dla dywanu Sierpinskiego");                // Display some text (you can use a format strings too)
        ImGui::SliderInt("Iteracje", &f, 1, 12);                          // Edit 1 int using a slider from 0 to 25
        ImGui::End();

        //Rendering
        ImGui::Render();
        int display_w, display_h;

        glfwMakeContextCurrent(window);
        glfwGetFramebufferSize(window, &display_w, &display_h);
        glViewport(0, 0, display_w, display_h);
        glClearColor(1.0f, 1.0f, 1.0f, 1.00f);
        glClear(GL_COLOR_BUFFER_BIT);

        Carpet(f, 1.0f, 1.0f, 0.0f, 0.0f, VBO, VAO, shaderProgram, shaderProgram2);

        glfwMakeContextCurrent(window);
        glfwSwapBuffers(window);
        glfwPollEvents();
    }


    // Cleanup
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();

    glfwDestroyWindow(window);
    glfwTerminate();





    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteBuffers(1, &EBO);

    glfwTerminate();
    return 0;
}