#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <ncurses.h>
#include <unistd.h>
#include <termios.h>
#include <limits.h>
#include <time.h>
#include <glad/glad.h>
#include <GLFW/glfw3.h>

#include "hash.h"
#include "structure.h"
#include "base.h"
#include "move.h"
#include "menus.h"
#include "proj.h"
#include "entities.h"
#include "display.h"
#include "generation.h"

double sim_time ;

void processInput(GLFWwindow *window, float dtime) {
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
        glfwSetWindowShouldClose(window, true);
    }
    if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
        for(int k = 0; k < 10; k++) {
            camz -= speed*cos(rot_hz)*cos(rot_vt)/10;
            camx -= speed*sin(rot_hz)*cos(rot_vt)/10;
            camy += speed*sin(rot_vt)/10;
            if(is_colliding(dtime)) {
                camz += speed*cos(rot_hz)*cos(rot_vt)/10;
                camx += speed*sin(rot_hz)*cos(rot_vt)/10;
                camy -= speed*sin(rot_vt)/10;
                k=11;
            }
        }
    }
    if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
        for(int k = 0; k < 10; k++) {
            camx -= speed*cos(rot_hz)/10;
            camz += speed*sin(rot_hz)/10;
            if(is_colliding(dtime)) {
                camx += speed*cos(rot_hz)/10;
                camz -= speed*sin(rot_hz)/10;
                k=11;
            }
        }
    }
    if(glfwGetKey(window, GLFW_KEY_Z) == GLFW_PRESS) {
        for(int k = 0; k < 10; k++) {
            camz += speed*cos(rot_hz)*cos(rot_vt)/10;
            camx += speed*sin(rot_hz)*cos(rot_vt)/10;
            camy -= speed*sin(rot_vt)/10;
            if(is_colliding(dtime)) {
                camz -= speed*cos(rot_hz)*cos(rot_vt)/10;
                camx -= speed*sin(rot_hz)*cos(rot_vt)/10;
                camy += speed*sin(rot_vt)/10;
                k=11;
            }
        }
    }
    if(glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) {
        for(int k = 0; k < 10; k++) {
            camx += speed*cos(rot_hz)/10;
            camz -= speed*sin(rot_hz)/10;
            if(is_colliding(dtime)) {
                camx -= speed*cos(rot_hz)/10;
                camz += speed*sin(rot_hz)/10;
                k=11;
            }
        }
    }

    if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) {
        stop_evetything = true ;
    }

    if(glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS) {
        rot_hz -= sensitivity;
    }
    if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
        rot_hz += sensitivity;
    }

    if(glfwGetKey(window, GLFW_KEY_P) == GLFW_PRESS) {
        rot_vt -= sensitivity;
    }
    if(glfwGetKey(window, GLFW_KEY_M) == GLFW_PRESS) {
        rot_vt += sensitivity;
    }
}

const char *vertexShaderSource = "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "uniform mat4 scale;\n"
    "uniform mat4 model;\n"
    "uniform mat4 view;\n"
    "uniform mat4 projection;\n"
    "void main() {\n"
    "   gl_Position = projection * view * model * scale * vec4(aPos, 1.0);\n"
    "}\0";

// Fragment Shader Source
const char *fragmentShaderSource = "#version 330 core\n"
    "uniform vec4 u_color;\n"
    "out vec4 FragColor;\n"
    "void main() {\n"
    "   FragColor = u_color;\n"
    "}\0";

const char *vertexShaderSourceR = "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "uniform mat4 scale;\n"
    "uniform mat4 slide;\n"
    "void main() {\n"
    "   gl_Position = slide * scale * vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
    "}\0";

const char *fragmentShaderSourceR = "#version 330 core\n"
    "uniform vec4 u_color2;\n"
    "out vec4 FragColor;\n"
    "void main() {\n"
    "   FragColor = u_color2;\n"
    "}\0";

int main_alt() {
    // glfw: initialize and configure
    // ------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // glfw window creation
    // --------------------
    GLFWwindow* window = glfwCreateWindow(1500, 1000, "yahoo", NULL, NULL);
    if (window == NULL)
    {
        fprintf(stderr, "ERROR : cannot initialize GL window");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        fprintf(stderr, "ERROR : cannot initialize GLAD loader");
        return -1;
    }

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_FRONT); 
    glDepthFunc(GL_LESS);

    init_csts();
    init_hashtbl();
    init_ent_generator(10);
    init_proj();
    parse_rooms(5);

    // ---------------------------------------------------------------------------------------------------------------------------------------------- //
    // ---------------------------------------------------------------------------------------------------------------------------------------------- //

    // build and compile our shader program
    // ------------------------------------
    // vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    // check for shader compile errors
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        fprintf(stderr, "ERROR : cannot initialize shader (1)");
    }

    // fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        fprintf(stderr, "ERROR : cannot initialize shader (3)");
    }

    // link shaders
    unsigned int shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    // main VAO/VBO
    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    glBindVertexArray(VAO);

    init_vertices();

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

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // ---------------------------------------------------------------------------------------------------------------------------------------------- //
    // ---------------------------------------------------------------------------------------------------------------------------------------------- //

    // build and compile our shader program
    // ------------------------------------
    // vertex shader
    unsigned int vertexShaderR = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShaderR, 1, &vertexShaderSourceR, NULL);
    glCompileShader(vertexShaderR);
    // check for shader compile errors
    glGetShaderiv(vertexShaderR, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShaderR, 512, NULL, infoLog);
        //std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // fragment shader
    unsigned int fragmentShaderR = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShaderR, 1, &fragmentShaderSourceR, NULL);
    glCompileShader(fragmentShaderR);
    // check for shader compile errors
    glGetShaderiv(fragmentShaderR, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShaderR, 512, NULL, infoLog);
        //std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // link shaders
    unsigned int shaderProgramR = glCreateProgram();
    glAttachShader(shaderProgramR, vertexShaderR);
    glAttachShader(shaderProgramR, fragmentShaderR);
    glLinkProgram(shaderProgramR);
    // check for linking errors
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgramR, 512, NULL, infoLog);
        //std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
    }
    glDeleteShader(vertexShaderR);
    glDeleteShader(fragmentShaderR);

    // rectangle VAO/VBO
    initMenus();

    unsigned int RVBO, RVAO;
    glGenVertexArrays(1, &RVAO);
    glGenBuffers(1, &RVBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    glBindVertexArray(RVAO);

    glBindBuffer(GL_ARRAY_BUFFER, RVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(rectDefault), rectDefault, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
    glBindBuffer(GL_ARRAY_BUFFER, 0); 

    // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
    // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
    glBindVertexArray(0); 

    // ---------------------------------------------------------------------------------------------------------------------------------------------- //
    // ---------------------------------------------------------------------------------------------------------------------------------------------- //

    int fps = 60 ;
    int interval = 1000000/fps ;

    clock_t finish = clock();
    clock_t origin = clock();

    while(!glfwWindowShouldClose(window)) {
        // input
        // -----
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        origin = clock();

        generate_nearby_chunks(1);

        glUseProgram(shaderProgram);
        glBindVertexArray(VAO);

        gl_initRender(shaderProgram, shaderProgram, VAO, VBO);
        gl_renderNearbyChunks(shaderProgram, shaderProgram, VAO, VBO, 1);
        gl_renderProj(shaderProgram, shaderProgram, VAO, VBO);

        glUseProgram(shaderProgramR);
        glBindVertexArray(RVAO);

        finish = clock();
        gl_drawInteger(shaderProgramR, (int)(1.0f/(((float)finish - (float)origin)/CLOCKS_PER_SEC)), -0.5f, 0.85f, 0.05, 32, 255, 32, 0.005, 1);

        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        processInput(window, ((float)finish - (float)origin)/CLOCKS_PER_SEC);
        teleport_on_edge();
        update_entities(((float)finish - (float)origin)/CLOCKS_PER_SEC);
        updateProj(((float)finish - (float)origin)/CLOCKS_PER_SEC);
        //printf("%f\n", 1.0f/(((float)finish - (float)origin)/CLOCKS_PER_SEC));
        //printf("%lf, %lf, %lf\n", camx, camy, camz);

        usleep(interval);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    //printf("10\n");
    //fflush(stdout);
    hashtbl_free(visited);
    free_proj();
    free_pool();

    // optional: de-allocate all resources once they've outlived their purpose:
    // ------------------------------------------------------------------------
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteProgram(shaderProgram);

    // glfw: terminate, clearing all previously allocated GLFW resources.
    // ------------------------------------------------------------------
    glfwTerminate();
    return 0;
}

int main(int argc, char** argv) {
    srand(time(NULL));
    return main_alt();
}