#include <stdio.h>

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "vertexShader.c"
#include "fragmentShader.c"
#include "objectHandler.c"
#include "matrixMath.h"
#include "transformation.h"
#include "wavefrontobj.h"

#define STB_IMAGE_IMPLEMENTATION
#include "../lib/stb_image.h"

#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stdbool.h>

GLuint program;

#define NUM_TEXTURES 5

#define DAY 0
#define NIGHT 1
#define CLOUDS 2
#define OCEAN 3
#define NORMAL 4

int flipFlag = 1;

GLuint textures[NUM_TEXTURES];
char* textureFiles[NUM_TEXTURES] = {
    "../texture/earth/day.png",
    "../texture/earth/night.png",
    "../texture/earth/clouds.png",
    "../texture/earth/ocean_mask.png",
    "../texture/earth/normal.png"
};

ObjectData* objectData;

bool exitRequested = false;

GLFWwindow* window;

GLfloat aspectRatio = 1.0f;

double timeBetweenUpdates = 0.2f;

double timeSinceUpdate = 0.0f;
int framesSinceUpdate = 0;

GLfloat step = 0.0f;
const GLfloat pi = 3.14159f;

vec3 cameraPosition = {0.0f, 3.0f, 5.5f};
vec3 objectPosition = {0.0f, 0.0f, 0.0f};
GLfloat radius = 1.0f;

int numModels = 0;
char* models[] = {
    "../obj/Xblock.obj",
    "../obj/Yblock.obj",
    "../obj/Yblock_rotated.obj",
    "../obj/Zblock.obj",
};

/**
 * Input handler for camera movement.
 *  */ 
void handleInputs(double deltaTime) {
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
        cameraPosition.z += deltaTime * 10;
    }
    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
        cameraPosition.z -= deltaTime * 10;
    }
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
        cameraPosition.x += deltaTime * 10;
    }
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
        cameraPosition.x -= deltaTime * 10;
    }
    if (glfwGetKey(window, GLFW_KEY_F) == GLFW_PRESS) {
        cameraPosition.y += deltaTime * 10;
    }
    if (glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS) {
        cameraPosition.y -= deltaTime * 10;
    }

    if (glfwGetKey(window, GLFW_KEY_L) == GLFW_PRESS) {
        objectPosition.x += deltaTime * 10;
    }
    if (glfwGetKey(window, GLFW_KEY_J) == GLFW_PRESS) {
        objectPosition.x -= deltaTime * 10;
    }
	if (glfwGetKey(window, GLFW_KEY_I) == GLFW_PRESS) {
        objectPosition.z += deltaTime * 10;
    }
    if (glfwGetKey(window, GLFW_KEY_K) == GLFW_PRESS) {
        objectPosition.z -= deltaTime * 10;
    }
	if (glfwGetKey(window, GLFW_KEY_O) == GLFW_PRESS) {
        radius += deltaTime * 10;
    }
    if (glfwGetKey(window, GLFW_KEY_U) == GLFW_PRESS) {
        radius -= deltaTime * 10;
    }
}

// input handler to quit with ESC
void keyboardHandler(GLFWwindow* window, int key, int scancode, int action, int mods) {
    if (action == GLFW_PRESS) {
        if (key == GLFW_KEY_ESCAPE) {
            exitRequested = true;
        }
    }
}

/**
 * Loads textures.
 */
void loadTexture(char* textureFile, GLuint* texture) {
    int width, height, nrChannels;
    unsigned char* image = stbi_load(textureFile, &width, &height, &nrChannels, 0);

    // default: 3 channels, RGB

    GLenum channelFormats[] = {
        0,
        GL_RED,
        GL_RG, 
        GL_RGB,
        GL_RGBA
    };
    GLenum format = channelFormats[nrChannels];

    glGenTextures(1, texture);
    glBindTexture(GL_TEXTURE_2D, *texture);

    printf("%s - %d\n", textureFile, nrChannels);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, format, GL_UNSIGNED_BYTE, image);
    // load texture using previously determined format ----- ^^^^^^

    glGenerateMipmap(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, 0);

    stbi_image_free(image);
}

void init(void) {
    // create and compile vertex shader
    const GLchar *vertexTextConst = vertexShader_glsl;

    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexTextConst, &vertexShader_glsl_len);
    glCompileShader(vertexShader);


    GLint status;
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
    
    if (!status) {
        printf("Error compiling vertex shader: ");
        GLchar infoLog[1024];
        glGetShaderInfoLog(vertexShader, 1024, NULL, infoLog);
        printf("%s",infoLog);
        exit(1);
    }

    vertexTextConst = NULL;

    // create and compile fragment shader
    const GLchar *fragmentTextConst = fragmentShader_glsl;

    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentTextConst, &fragmentShader_glsl_len);
    glCompileShader(fragmentShader);

    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status);
    
    if (!status) {
        printf("Error compiling fragment shader: ");
        GLchar infoLog[1024];
        glGetShaderInfoLog(fragmentShader, 1024, NULL, infoLog);
        printf("%s",infoLog);
        exit(1);
    }

    // create and link shader program
    program = glCreateProgram();
    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);
    glLinkProgram(program);

    glGetProgramiv(program, GL_LINK_STATUS, &status);

    if (!status) {
        printf("Error linking program: ");
        GLchar infoLog[1024];
        glGetProgramInfoLog(program, 1024, NULL, infoLog);
        printf("%s",infoLog);
        exit(1);
    }
    glValidateProgram(program);


    glGetProgramiv(program, GL_VALIDATE_STATUS, &status);

    if (!status) {
        printf("Error validating program: ");
        GLchar infoLog[1024];
        glGetProgramInfoLog(program, 1024, NULL, infoLog);
        printf("%s",infoLog);
        exit(1);
    }


    // --------------- READ MODEL FILES
    
    //objectData = readObjFiles(&models, numModels);
    char* c = "../obj/Yblock.obj";
    objectData = readSingleObjFile(&c, 10, &numModels);
    printf("\nAmount %d\n", numModels);
    fflush(stdout);
    /*
    objectData = malloc(numModels * sizeof(ObjectData));
    for (int i = 0; i < numModels; i++) {

        glGenVertexArrays(1, &objData->vao);
        glGenBuffers(1, &objData->vbo);

        glBindVertexArray(objData->vao);
        glBindBuffer(GL_ARRAY_BUFFER, objData->vbo);
        glBufferData(GL_ARRAY_BUFFER, objData->object.numFaces * 3 * sizeof(Vertex), objData->object.vertices, GL_STATIC_DRAW);

        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)0);
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)(3 * sizeof(GLfloat)));
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)(6 * sizeof(GLfloat)));
        glEnableVertexAttribArray(2);

        glBindVertexArray(0);

        objectData[i] = objData;
    }
    */

    stbi_set_flip_vertically_on_load(flipFlag);
    // -------------- READ TEXTURE FILES
    for (int i = 0; i < NUM_TEXTURES; i++) {
        loadTexture(textureFiles[i], &textures[i]);
    }

    // ENABLE BACKFACE CULLING
    glFrontFace(GL_CCW);
    glEnable(GL_CULL_FACE);

    // ENABLE DEPTH BUFFER
    glEnable(GL_DEPTH_TEST);

    glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
}

void updateStats() {
    printf("\rFPS: %.1f", framesSinceUpdate / timeSinceUpdate);
    printf(" - Camera Position: [%f, %f, %f]", cameraPosition.x, cameraPosition.y, cameraPosition.z);
    fflush(stdout);
}

/**
 * Main draw function.
 */
void draw(void) {

    // FPS Counter
    framesSinceUpdate++;
    double deltaTime = glfwGetTime();
    timeSinceUpdate += deltaTime;
    glfwSetTime(0.0f);

    if (timeSinceUpdate >= timeBetweenUpdates) {
        updateStats();
        timeSinceUpdate = 0.0f;
        framesSinceUpdate = 0;
    }

    // camera movement
    handleInputs(deltaTime);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glUseProgram(program);

    // step for rotations
    // counts up to 1.0 and then resets back to 0.0 forever
    step += deltaTime / 15;
    if (step > 1.0f) step -= 1.0f;
    if (step < 0.0f) step += 1.0f;

    // step multiplied by pi * 2 for use in rotation and trig functions
    GLfloat stepi = step * pi * 2;

    // ------------- VIEWING TRANSFORMATION -------------------
    vec3 origin = {0.0f, 0.0f, 0.0f};
    vec3 up = {0.0f, 1.0f, 0.0f};

    mat4 viewingTransformation;
    lookAt(&viewingTransformation, &cameraPosition, &origin, &up);

    // -------------- PROJECTION TRANSFORMATION ----------------
    mat4 projectionTransformation;
    GLfloat near = 0.1f;
    GLfloat far = 20.0f;
    perspectiveProjection(&projectionTransformation, near, far);

    // -------------- NORMALISATION TRANSFORMATION -------------
    mat4 normalisationTransformation;
    GLfloat fovy = pi / 2;
    normalisedDeviceCoordinatesFov(&normalisationTransformation, fovy, aspectRatio, near, far);

    mat4 projection;
    identity(&projection);
    multiply(&projection, &projectionTransformation, &projection);
    multiply(&projection, &normalisationTransformation, &projection);

    // ------------- DRAW EACH OBJECT SEPARATELY ----------------
    for (int i = 0; i < numModels; i++) {
        // Reset model transformation for each object
        mat4 modelTransformation;
        identity(&modelTransformation);

        // Apply object-specific transformations
        vec3 v = {
            (GLfloat)i*2+objectPosition.x,
            0.0f+objectPosition.y,
            0.0f+objectPosition.z
        };
        translate(&modelTransformation, &modelTransformation, &v);
        

        mat4 modelView;
        identity(&modelView);
        multiply(&modelView, &modelTransformation, &modelView);
        multiply(&modelView, &viewingTransformation, &modelView);

        // calculate matrix for normals
        mat3 normalModelView;
        mat3From4(&normalModelView, &modelView);
        mat3Inverse(&normalModelView, &normalModelView);
        mat3Transpose(&normalModelView, &normalModelView);

        // send transformation matrix to shader
        glUniformMatrix4fv(glGetUniformLocation(program, "modelView"), 1, GL_FALSE, (GLfloat*)&modelView);
        glUniformMatrix3fv(glGetUniformLocation(program, "normalModelView"), 1, GL_FALSE, (GLfloat*)&normalModelView);
        glUniformMatrix4fv(glGetUniformLocation(program, "projection"), 1, GL_FALSE, (GLfloat*)&projection);

        // SET MATERIAL DATA
        glUniform1f(glGetUniformLocation(program, "shininess"), 60.0f * 4.0f);

        // SET LIGHT DATA
        glUniform4f(glGetUniformLocation(program, "lightColor"), 1.0f, 1.0f, 1.0f, 1.0f);
        glUniform4f(glGetUniformLocation(program, "ambientLight"), 0.05f, 0.05f, 0.05f, 1.0f);

        // BIND TEXTURES
        GLuint textureLocation;
        textureLocation = glGetUniformLocation(program, "day");
        glUniform1i(textureLocation, 0);
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, textures[DAY]);

        textureLocation = glGetUniformLocation(program, "night");
        glUniform1i(textureLocation, 1);
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, textures[NIGHT]);

        textureLocation = glGetUniformLocation(program, "clouds");
        glUniform1i(textureLocation, 2);
        glActiveTexture(GL_TEXTURE2);
        glBindTexture(GL_TEXTURE_2D, textures[CLOUDS]);

        textureLocation = glGetUniformLocation(program, "ocean");
        glUniform1i(textureLocation, 3);
        glActiveTexture(GL_TEXTURE3);
        glBindTexture(GL_TEXTURE_2D, textures[OCEAN]);

        textureLocation = glGetUniformLocation(program, "normalMap");
        glUniform1i(textureLocation, 4);
        glActiveTexture(GL_TEXTURE4);
        glBindTexture(GL_TEXTURE_2D, textures[NORMAL]);

        // draw each object separately
        glBindVertexArray(objectData[i].vao);
        glDrawArrays(GL_TRIANGLES, 0, objectData[i].object.length * 3);
    }
}

/**
 *  Changes viewport size and adjust aspect ratio when changing window size
 */
void framebuffer_size_callback(GLFWwindow *window, int width, int height) {
    glViewport(0, 0, width, height);
    aspectRatio = (float)width / height;
}

/**
 * Main function.
 */
int main(int argc, char **argv) {
    // initialise window
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    window = glfwCreateWindow(700, 700, "Computergrafik 1", NULL, NULL);

    if (!window) {
        printf("Failed to create window\n");
        glfwTerminate();
        return -1;
    }

    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwMakeContextCurrent(window);

    // disable framerate cap
    glfwSwapInterval(0);

    // register keyboard event handler
    glfwSetKeyCallback(window, keyboardHandler);

    // initialise glew
    glewInit();

    printf("OpenGL version supported by this platform (%s):\n", glGetString(GL_VERSION));

    init();
    // exit when window should close or exit is requested (ESC)
    while (!glfwWindowShouldClose(window) && !exitRequested) {
        draw();

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();

    return 0;
}
