#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdbool.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;
int triCount;
unsigned int fffff;
int gamemode;

double jPress = false;
double gPress = false;
double rPress = false;

void reset_everything(GLFWwindow *window, int count, char* folder) {
    hashtbl_free(visited);
    free_proj();
    free_interf();
    free_pool();
    
    //init_csts();
    init_hashtbl();
    init_ent_generator(10);
    init_proj();
    init_interf(window);
    parse_rooms(count, folder);
}

void processInput(GLFWwindow *window, float dtime) {
    // quit w
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
        glfwSetWindowShouldClose(window, true);
    }

    // horizontal movement
    bool pressed = false;
    if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
        if(gamemode == 1) {
            for(int k = 0; k < 10; k++) {
                camz -= creative_speed*cos(rot_hz)*cos(rot_vt)/10;
                camx -= creative_speed*sin(rot_hz)*cos(rot_vt)/10;
                camy += creative_speed*sin(rot_vt)/10;
                if(is_colliding(dtime)) {
                    camz += creative_speed*cos(rot_hz)*cos(rot_vt)/10;
                    camx += creative_speed*sin(rot_hz)*cos(rot_vt)/10;
                    camy -= creative_speed*sin(rot_vt)/10;
                    k=11;
                }
            }
        } else {
            camvz = -speed*cos(rot_hz);
            camvx = -speed*sin(rot_hz);
        }
        pressed = true;
        //camvy = vtmult*speed*sin(rot_vt);
    }
    if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
        if(gamemode == 1) {
            for(int k = 0; k < 10; k++) {
                camx -= creative_speed*cos(rot_hz)/10;
                camz += creative_speed*sin(rot_hz)/10;
                if(is_colliding(dtime)) {
                    camx += creative_speed*cos(rot_hz)/10;
                    camz -= creative_speed*sin(rot_hz)/10;
                    k=11;
                }
            }
        } else {
            camvx = -speed*cos(rot_hz);
            camvz = speed*sin(rot_hz);
        }
        pressed = true;
    }
    if(glfwGetKey(window, GLFW_KEY_Z) == GLFW_PRESS) {
        if(gamemode == 1) {
            for(int k = 0; k < 10; k++) {
                camz += creative_speed*cos(rot_hz)*cos(rot_vt)/10;
                camx += creative_speed*sin(rot_hz)*cos(rot_vt)/10;
                camy -= creative_speed*sin(rot_vt)/10;
                if(is_colliding(dtime)) {
                    camz -= creative_speed*cos(rot_hz)*cos(rot_vt)/10;
                    camx -= creative_speed*sin(rot_hz)*cos(rot_vt)/10;
                    camy += creative_speed*sin(rot_vt)/10;
                    k=11;
                }
            }
        } else {
            camvz = speed*cos(rot_hz);
            camvx = speed*sin(rot_hz);
        }
        pressed = true;
        //camvy = -vtmult*speed*sin(rot_vt);
    }
    if(glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) {
        if(gamemode == 1) {
            for(int k = 0; k < 10; k++) {
                camx += creative_speed*cos(rot_hz)/10;
                camz -= creative_speed*sin(rot_hz)/10;
                if(is_colliding(dtime)) {
                    camx -= creative_speed*cos(rot_hz)/10;
                    camz += creative_speed*sin(rot_hz)/10;
                    k=11;
                }
            }
        } else {
            camvx = speed*cos(rot_hz);
            camvz = -speed*sin(rot_hz);
        }
        pressed = true;
    }

    // jumps
    if(gamemode == 0 && njumps > 0 && glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) {
        if(jPress) {
            camvy = vtmult*speed;
            njumps -= 1;
            jPress = false;
        }
    } else {
        jPress = true;
    }
    if(!pressed) {
        camvx *= (1.0-1.0*5.0*((double)dtime));
        camvz *= (1.0-1.0*5.0*((double)dtime));
    }

    // gamemode
    if(glfwGetKey(window, GLFW_KEY_G) == GLFW_PRESS) {
        if(!gPress) {
            gPress = true;
            gamemode = 1-gamemode;
            njumps = 3;
            camvx = 0.0;
            camvy = 0.0;
            camvz = 0.0;
        }   
    } else {
        gPress = false;
    }

    // camera rotation
    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 = maxd(-3.14159/2.0, rot_vt-sensitivity);
    }
    if(glfwGetKey(window, GLFW_KEY_M) == GLFW_PRESS) {
        rot_vt = mind(3.14159/2.0, rot_vt+sensitivity);
    }

    // reset
    if(glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS) {
        if(!isMenuOpen() && !rPress) {
            rPress = true;
            reset_everything(window, 7, "templates/");
        }   
    }/*else {
        rPress = false;
    }*/
}

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);

    //glfwSetMouseButtonCallback(window, mouse_button_callback);

    init_csts();
    init_hashtbl();
    init_ent_generator(10);
    init_proj();
    init_interf(window);
    build_all_menus();
    parse_rooms(7, "templates/");

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

    // 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); 

    // ---------------------------------------------------------------------------------------------------------------------------------------------- //
    // ---------------------------------------------------------------------------------------------------------------------------------------------- //
    fffff = shaderProgram;

    int fps = 90;
    int interval = 1000000/fps;
    double slp_time = 1.0/fps;

    float delta = 0.0f;
    double deltad = 0.0;

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

    while(!glfwWindowShouldClose(window) && player_hp > 0) {
        // input
        // -----
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        triCount = 0;

        fflush(stdout);
        generate_nearby_chunks(1);
        fflush(stdout);

        // draw the map
        glUseProgram(shaderProgram);
        glBindVertexArray(VAO);

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

        // draw data
        glUseProgram(shaderProgramR);
        glBindVertexArray(RVAO);

        gl_drawInteger(shaderProgramR, (int)(1.0f/(delta)), 0.0f, -0.92f, 0.05, 32, 255, 32, 0.005, -1);
        gl_drawInteger(shaderProgramR, triCount, 0.0f, 0.92f, 0.04f, 128, 128, 128, 0.005f, 1);
        gl_drawData(shaderProgramR);

        if(!isInMenu(window, shaderProgramR)) {
            processInput(window, delta);
            if(gamemode == 0) {
                movePlayerG(delta);
            }
            teleport_on_edge();
            update_entities(delta);
            updateProj(delta);
        }

        usleep(max(0, interval-(int)(1000000*delta)));
        sim_time += deltad;

        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        glfwSwapBuffers(window);
        glfwPollEvents();

        finish = clock();
        delta = slp_time+((float)finish - (float)origin)/CLOCKS_PER_SEC;
        deltad = slp_time+((double)finish - (double)origin)/CLOCKS_PER_SEC;
        origin = clock();
        incr = 0.0f;
    }

    hashtbl_free(visited);
    free_proj();
    free_interf();
    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));
    triCount = 0;
    sim_time = 0.0;
    gamemode = 0;
    return main_alt();
}