#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <glm/ext/matrix_clip_space.hpp>
#include <glm/ext/matrix_transform.hpp>
#include <glm/ext/vector_float3.hpp>
#include <stdio.h>

#include "util.hpp"
#include "shaders.hpp"
#include "body.hpp"
#include "tcp_server.hpp"

static GLFWwindow* window;
static float width, height;

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

void process_input() {
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}

static bool mouse_pressed = false;
static bool scroll_pressed = false;
static double prev_cursor_x, prev_cursor_y;

static double theta = 0.0; // angle of camera trans vect wrt x-z plane
static double phi = 0.0; // angle of camera trans vect wrt x-axis

static glm::vec3 camera_loc = glm::vec3(0, 0, 2);
static glm::vec3 focal_point = glm::vec3(0, 0, 0);
static glm::vec3 up = glm::vec3(0, 1, 0);
static glm::mat4 camera_t = glm::lookAt(camera_loc, focal_point, up);

static glm::vec4 strafe_x = camera_t[0];
static glm::vec4 strafe_y = camera_t[1];

static void cursor_position_callback(GLFWwindow* window, double xpos, double ypos) {
    float dx = (xpos - prev_cursor_x);
    float dy = (ypos - prev_cursor_y);
    prev_cursor_x = xpos;
    prev_cursor_y = ypos;
    if (mouse_pressed) {
        phi += dx / width * glm::radians(360.0);
        theta += dy / height * glm::radians(360.0);
    }

    if (scroll_pressed) {
        focal_point += strafe_x * (dx / 300) + strafe_y * (dy / 300);
    }

    double len = glm::length(camera_loc);
    camera_loc.x = len * glm::cos(theta) * glm::cos(-phi);
    camera_loc.y = len * glm::sin(theta);
    camera_loc.z = -len * glm::cos(theta) * glm::sin(-phi);

    camera_t = glm::lookAt(camera_loc, focal_point, up);
}

void mouse_button_callback(GLFWwindow* window, int button, int action, int mods) {
    if (button == GLFW_MOUSE_BUTTON_RIGHT) {
        mouse_pressed = action == GLFW_PRESS;
    }

    if (button == GLFW_MOUSE_BUTTON_MIDDLE) {
        scroll_pressed = action == GLFW_PRESS;
        strafe_x = camera_t[0];
        strafe_y = camera_t[1];
    }

    glfwGetCursorPos(window, &prev_cursor_x, &prev_cursor_y);
}

void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
    glm::vec4 k = camera_t[2];
    float d = yoffset;

    camera_loc += k * (d / 10 * max(glm::length(camera_loc), 1.0f));

    camera_t = glm::lookAt(camera_loc, focal_point, up);
}

bool glfw_setup() {
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    // glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    window = glfwCreateWindow(800, 800, "LearnOpenGL", NULL, NULL);
    if (window == NULL) {
        printf("Failed to create GLFW window\n");
        glfwTerminate();
        return false;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetCursorPosCallback(window, cursor_position_callback);
    glfwSetMouseButtonCallback(window, mouse_button_callback);
    glfwSetScrollCallback(window, scroll_callback);

    cursor_position_callback(window, 0, 0);
    return true;
}

int main() {
    //tcpserver server;
    //if (!create_server(&server, "127.0.0.1", 5000, 1)) {
    //    //return -1;
    //}

    if (!glfw_setup())
        return -1;

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        printf("Failed to initialize GLAD\n");
        return -1;
    }
    glViewport(0, 0, 800, 800);
    width = 800;
    height = 800;

    uint shader;
    const char* vertex_filepath = "src/shaders/vertex.glsl";
    const char* fragment_filepath = "src/shaders/fragment.glsl";
    if (!load_shader(&shader, vertex_filepath, fragment_filepath))
        return -1;

    // glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    glClearColor(0, 0, 0, 0);
    glClear(GL_COLOR_BUFFER_BIT); // Write to back buffer

    glfwSwapBuffers(window); // front buffer is now back
    glClear(GL_COLOR_BUFFER_BIT); // Write to back buffer again (former front buf)

    body b;
    if (!load_body(&b, "Icosphere.obj"))
        return -1;
    b.shader = shader;
    b.pose = glm::translate(b.pose, glm::vec3(0, 0, 0));
    b.color = glm::vec4(0.5, 0, 0, 1);

    body b2;
    if (!load_body(&b2, "Icosphere.obj"))
        return -1;
    b2.shader = shader;
    b2.pose = glm::translate(b.pose, glm::vec3(2, 0, 0));
    b2.color = glm::vec4(0, 0.5, 0, 1);

    // glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    // set_uniform(shader, "color", glm::vec4 { sin(time), sin(time + glm::radians(45.0f)), sin(time +
    // glm::radians(90.0f)), 1.0 } / 2.0f); time = glfwGetTime();

    glDisable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);

    float time;
    glm::mat4 projection_t
        = glm::perspective(glm::radians(60.0f), (float)width / (float)height, 0.1f, 1300.0f);

    while (!glfwWindowShouldClose(window)) {
        process_input();
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        set_uniform(shader, "camera_t", camera_t);
        set_uniform(shader, "projection_t", projection_t);

        draw_body(b);
        draw_body(b2);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    glfwTerminate();
    return 0;
}