#include "cubes.h"
#include "gen.h"
#include "linmath.h"
#include <GLFW/glfw3.h>
#include <stdio.h>

int is_space;

int collision(struct chunk chunk, vec3 pos, vec3 dir_temp, int col, int n) {
  vec3 closestVert = {floor(pos[0] + 0.5), floor(pos[1] + 0.5),
                      floor(pos[2] + 0.5)};
  if (col) {
    double xd = dir_temp[0] / (closestVert[0] - (pos[0]));
    double yd = dir_temp[1] / (closestVert[1] - (pos[1]));
    double zd = dir_temp[2] / (closestVert[2] - (pos[2]));
    if (xd < 0 && n == 0) {
      dir_temp[0] = 0;
      pos[0] = closestVert[0];
      return 1;
    }
    if (yd < 0 && n == 1) {
      dir_temp[1] = 0;
      pos[1] = closestVert[1];
      return 1;
    }
    if (zd < 0 && n == 2) {
      dir_temp[2] = 0;
      pos[2] = closestVert[2];
      return 1;
    }
  }

  return 0;
}

struct v3f control_handler(double cx, double cy, vec3 pos, vec3 dir_temp,
                           GLFWwindow *window, struct chunk chunk) {
  vec3 direction = {cosf(cy) * sinf(cx) * 0.1, sinf(cy) * 0.1,
                    cosf(cy) * cosf(cx) * 0.1};
  vec3 right = {sinf(cx - 3.14f / 2.0f) * 0.1, 0,
                cosf(cx - 3.14f / 2.0f) * 0.1};

  vec3 front = {sinf(cx) * 0.1, 0, cosf(cx) * 0.1};
  vec3 pos_temp = {0, 0, 0};

  vec3_dup(pos_temp, pos);

  if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
    vec3_sub(dir_temp, dir_temp, front);
  }

  if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
    vec3_add(dir_temp, dir_temp, front);
  }

  if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
    vec3_add(dir_temp, dir_temp, right);
  }

  if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
    vec3_sub(dir_temp, dir_temp, right);
  }

  vec3_scale(dir_temp, dir_temp, 0.6);

  vec3 off = {0, 0, 0};
  int col = 0;
  for (int a = -2; a < 0; a++) {
    off[1] = a;
    col = col || gen_cube(pos[0] + off[0], pos[1] + off[1], pos[2] + off[2],
                          chunk, 0, -1);
  }

  vec3_add(pos, pos, dir_temp);
  dir_temp[1] -= 0.05;
  if (collision(chunk, pos, dir_temp, col, 1)) {
    col = 0;
    for (int a = -2; a < 0; a++) {
      off[1] = a;
      col = col || gen_cube(pos[0] + off[0], pos[1] + off[1], pos[2] + off[2],
                            chunk, 0, -1);
    }

    if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) {
      is_space = 3;
    }
  }

  if (is_space > 0) {
    dir_temp[1] = 0.8;
  }
  is_space--;

  collision(chunk, pos, dir_temp, col, 0);
  collision(chunk, pos, dir_temp, col, 2);

  struct v3f dirOut;
  vec3_dup(dirOut.pos, direction);

  return dirOut;
}

struct v3f control_rtrace(double cx, double cy, vec3 pos, int mode) {
  struct chunk placeChunk;
  vec3 direction = {cosf(cy) * sinf(cx) * 0.1, sinf(cy) * 0.1,
                    cosf(cy) * cosf(cx) * 0.1};

  vec3 temp_pos;
  vec3 temp_dir;
  vec3_dup(temp_pos, pos);

  for (int i = 0; i < CHUNK_LENGTH * 4; i++) {

    double xd =
        fabs(direction[0]) / (((direction[0] > 0) ? (1.0 - fmod(temp_pos[0], 1))
                                                  : fmod(temp_pos[0], 1)) +
                              0.01);
    double yd =
        fabs(direction[1]) / (((direction[1] > 0) ? (1.0 - fmod(temp_pos[1], 1))
                                                  : fmod(temp_pos[1], 1)) +
                              0.01);
    double zd =
        fabs(direction[2]) / (((direction[2] > 0) ? (1.0 - fmod(temp_pos[2], 1))
                                                  : fmod(temp_pos[2], 1)) +
                              0.01);

    if (xd > yd && xd > zd && !isnan(xd)) {
      vec3_scale(temp_dir, direction, fabs(1 / xd + 0.01));
    } else if (yd > zd && !isnan(yd)) {
      vec3_scale(temp_dir, direction, fabs(1 / yd + 0.01));
    } else if (!isnan(zd)) {
      vec3_scale(temp_dir, direction, fabs(1 / zd + 0.01));
    }

    vec3_add(temp_pos, temp_pos, temp_dir);

    if (gen_cube(temp_pos[0],temp_pos[1],temp_pos[2],placeChunk,0,-1) != 0) {
      if (mode == 0) vec3_sub(temp_pos,temp_pos,temp_dir);
      break;
    }
  }

  struct v3f out_pos;
  vec3_dup(out_pos.pos, temp_pos);

  return out_pos;
}

void control_lclick(double cx, double cy, vec3 pos) {
  struct v3f highlighted = control_rtrace(cx, cy, pos, 1);
  struct chunk placeChunk;
  int cube = gen_cube(highlighted.pos[0],highlighted.pos[1],highlighted.pos[2],placeChunk,0,-1);
  if (cube == 0) return;
  gen_cube(highlighted.pos[0],highlighted.pos[1],highlighted.pos[2],placeChunk,0,0);
}

void control_rclick(double cx, double cy, vec3 pos) {
  struct v3f highlighted = control_rtrace(cx, cy, pos, 0);
  struct chunk placeChunk;
  int cube = gen_cube(highlighted.pos[0],highlighted.pos[1],highlighted.pos[2],placeChunk,0,-1);
  if (cube != 0) return;
  gen_cube(highlighted.pos[0],highlighted.pos[1],highlighted.pos[2],placeChunk,0,1);
}