#ifndef MAIN_CPP

#include <glad/glad.h>
#include <GLFW/glfw3.h>

#include <iostream>

#include <random> // I am using standart library RNG because I am lazy and wanted to create quick code snippet
// upgrade to this: https://arvid.io/2018/06/30/on-cxx-random-number-generator-quality/ whenever, if ever I feel like it
#include <chrono> // for std::chrono

#include "constants.hpp"

void configureGLFW() {
    // first argument tells us what option to configure
    // second is to what we set the value of this option
    // see: https://www.glfw.org/docs/latest/window.html#window_hints
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    // we set GLFW to 3.3 CORE
    // core profile gives us access to smaller subset of OGL without backwards compatible features

    // if we are on Mac OS X we need this for our code to work
    #ifdef __APPLE__
        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    #endif
}

void instantiateGLFWwindow() {
    // Initialize GLFW
    glfwInit();
    configureGLFW();
}

GLFWwindow* createWindowObject() {
    // First two arguments are width and height 
    // Third is the name of the window
    // We ignore last two
    GLFWwindow* window = glfwCreateWindow(constants::MAIN_WINDOW_WIDTH, constants::MAIN_WINDOW_HEIGHT, constants::MAIN_WINDOW_NAME, NULL, NULL);
    return window;
}

int initializeGLAD() 
{
    // we load address of OGL OS-specific function pointers
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }    
    return 0;
}

// resizes viewport when user resizes window
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    glViewport(0, 0, width, height);
}  

void viewPort(GLFWwindow* window)
{
    // We tell OGL size of rendering window
    // First two define left corner of window
    // 3th and 4th width and height of rendering window
    // we could set them to be smaller than window dimension, ogl rendering will be then displayed in smaller window
    glViewport(0, 0, constants::MAIN_WINDOW_WIDTH, constants::MAIN_WINDOW_HEIGHT);
    // processed coordinates are between -1 and 1 so here we map:
    // (-1 to 1) to (0, constants::MAIN_WINDOW_WIDTH) and (0, constants::MAIN_WINDOW_HEIGHT)
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);  
    // we call framebuffer_size_callback on every window resize
}

void processInput(GLFWwindow *window)
{
    // glfwGetKey takes window and key as an input and checks is currently being pressed 
    // if the user pressed escape we close window
    if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
    if(glfwGetKey(window, GLFW_KEY_C) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

int shaderProgramLinkingSuccessful(const unsigned int shaderProgram)
{
    // check if compilation was successful
    // int because glGetShaderiv requires int
    int successfulLinking;
    // here we store info about compilation
    char infoLog[512];
    // check if compilation was successful 
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &successfulLinking);
    // if not display compilation log
    if(!successfulLinking)
    {
        glGetProgramInfoLog(shaderProgram, sizeof(infoLog) / sizeof(infoLog[0]), NULL, infoLog);
        std::cout << "ERROR shaderProgram compilation failed \n" << infoLog << std::endl;
    }
    return successfulLinking;
}


int shaderCompilationSuccessful(const unsigned int shader)
{

    
    // check if compilation was successful
    // int because glGetShaderiv requires int
    int successfulCompilation;
    // here we store info about compilation
    char infoLog[512];
    // check if compilation was successful 
    glGetShaderiv(shader, GL_COMPILE_STATUS, &successfulCompilation);
    // if not display compilation log
    if(!successfulCompilation)
    {
        glGetShaderInfoLog(shader, sizeof(infoLog) / sizeof(infoLog[0]), NULL, infoLog);
        std::cout << "ERROR vertex shader compilation failed \n" << infoLog << std::endl;
    }
    return successfulCompilation;
}

unsigned int compileShader(const GLenum shaderType, const char * shaderSource)
{
    // we create vertex shader and assign its id to shader variable
    unsigned int shaderID;
    shaderID = glCreateShader(GL_VERTEX_SHADER);

    // attach shader source code to shader object
    // from left: shader object to compile, how many strings as source code, actual source code (we leave the 4th as NULL)
    glShaderSource(shaderID, 1, &shaderSource, NULL);
    // compile shader
    glCompileShader(shaderID);
    if(!shaderCompilationSuccessful(shaderID)) return 0;
    return shaderID;
}

void drawTriangle()
{
    // we specify three vertices
    // each of them with position in 3d space
    // x y z
    const float triangleVertices[] = {
        -0.5f, -0.5f, 0.0f,
        0.5f, -0.5f, 0.0f,
        0.0f,  0.5f, 0.0f
    };

    // stores vertices in gpu memory
    unsigned int vertexBufferObject;
    // this is open gl object so we refer it by its ID generated here and stored in vertexBufferObject variable
    glGenBuffers(1, &vertexBufferObject);
    
    // buffer type of vertex buffer object is GL_ARRAY_BUFFER
    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
    // now whenever we change GL_ARRAY_BUFFER we change bound buffer vertexBufferObject

    /* we copy vertex data into buffer memory
    GL_STREAM_DRAW: the data is set only once and used by the GPU at most a few times.
    GL_STATIC_DRAW: the data is set only once and used many times.
    GL_DYNAMIC_DRAW: the data is changed a lot and used many times.
    */
    glBufferData(GL_ARRAY_BUFFER, sizeof(triangleVertices), triangleVertices, GL_STATIC_DRAW);


    unsigned int vertexShader = compileShader(GL_VERTEX_SHADER, constants::vertexShaderSource);
    if(vertexShader == 0) return;

    unsigned int fragmentShader = compileShader(GL_FRAGMENT_SHADER, constants::fragmentShaderSource);
    if(fragmentShader == 0) return;

    // link shader objects into shader program 
    // will store shader program id
    unsigned int shaderProgram;
    // creates program 
    shaderProgram = glCreateProgram();

    // attachShaders
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);

    // link shaders
    glLinkProgram(shaderProgram);
    if(!shaderProgramLinkingSuccessful(shaderProgram)) return;

    // activate program
    // after that every shader and rendering call will use this program object
    glUseProgram(shaderProgram);
    
    // delete shaders (they are linked into shaderProgram and we do not need them anymore)
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
}



void renderLoop(GLFWwindow* window)
{
    // glfwWindowShouldClose checks if GLFW was instructed to close
    while(!glfwWindowShouldClose(window))
    {
        // input
        processInput(window);
        // We specify the color to clear the screen with
        // RGB and alpha value
        glClearColor( constants::LEARN_OPEN_GL_COLOR.red, constants::LEARN_OPEN_GL_COLOR.green, constants::LEARN_OPEN_GL_COLOR.blue, constants::LEARN_OPEN_GL_COLOR.alpha);
        // There is GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT and GL_STENCIL_BUFFER_BIT
        glClear(GL_COLOR_BUFFER_BIT);


        // swaps buffer containing color values of each pixel in window
        // there is front buffer (final image) and back buffer (where all rendering commands draw to)
        // when back buffer is ready we swap it with front buffer to eliminate flickering
        glfwSwapBuffers(window);

        // glfwPollEvents checks if any event (like mouse/keyboard input was triggered), updates window state and calls functions (which we register via callback methods)
        glfwPollEvents();    
        drawTriangle();

    }
}

int main()
{
    instantiateGLFWwindow();

    GLFWwindow* window = createWindowObject();
    // function returns GLFWWindow object
    
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    // we make context of this window main context of current thread
    glfwMakeContextCurrent(window);
    
    if(initializeGLAD() == -1) return -1;
    viewPort(window);
    renderLoop(window);

    // clean GLFW resources
    glfwTerminate();
    return 0;
}

#endif