#include "const.h"
#include "gen.h"
#include <pthread.h>
#include <stdio.h>

struct args {
  Vertex *cube;
  VertexI pos;
  int is_text;
  int a;
  int i;
};

void gen_face(Vertex *cube, int i, int x, int y, int z, int x2, int y2, int z2,
              int j, int is_text, Chunk dat) {
  VertexI a = {{x, y, z}};
  Vertex a2 = {{x, y, z}};

  if (is_text) {
    a.pos[i]--;
    int exists = 0;
    exists = (cube_exists(x, y, z, dat) !=
              cube_exists(a.pos[0], a.pos[1], a.pos[2], dat));

    a2.pos[0] = exists ? TEXT_GAP_H * i : -1.0;
    a2.pos[1] = exists ? TEXT_GAP_V * i : -1.0;
    a2.pos[2] = 0;
  }

  Vertex b = a2;
  Vertex c = a2;
  Vertex d = a2;

  if (is_text) {
    b.pos[0] += TEXT_GAP_H;
    c.pos[1] += TEXT_GAP_V;
    d.pos[0] += TEXT_GAP_H;
    d.pos[1] += TEXT_GAP_V;
  } else {
    b.pos[(i == 0) ? 1 : 0]++;
    c.pos[(i == 2) ? 1 : 2]++;
    d.pos[(i == 0) ? 1 : 0]++;
    d.pos[(i == 2) ? 1 : 2]++;
  }

  cube[j] = a2;
  cube[j + 1] = b;
  cube[j + 2] = c;
  cube[j + 3] = c;
  cube[j + 4] = b;
  cube[j + 5] = d;
}

void *gen_chunk(void *args) {
  struct args args2 = ((struct args *)args)[0];

  int i = args2.i;
  int x2 = args2.pos.pos[0];
  int y2 = args2.pos.pos[1];
  int z2 = args2.pos.pos[2];
  Vertex *cube = args2.cube;
  int is_text = args2.is_text;
  Chunk chunk =
      fetch_chunk(x2 / CHUNK_LENGTH, y2 / CHUNK_LENGTH, z2 / CHUNK_LENGTH);

  printf("progress on this thread (%i / %i)\n", args2.a, CHUNK_ALL);

  purge_chunks();
  for (int y4 = 0; y4 < CHUNK_LENGTH; y4++) {

    for (int x4 = 0; x4 < CHUNK_LENGTH; x4++) {

      for (int z4 = 0; z4 < CHUNK_LENGTH; z4++) {
        int y3 = y2 + y4;
        int x3 = x2 + x4;
        int z3 = z2 + z4;

        gen_face(cube, 0, x3, y3, z3, x4, y4, z4, i, is_text, chunk);
        gen_face(cube, 1, x3, y3, z3, x4, y4, z4, i + 6, is_text, chunk);
        gen_face(cube, 2, x3, y3, z3, x4, y4, z4, i + 12, is_text, chunk);
        i += 18;
      }
    }
  }
  return NULL;
}

void gen_cubes(Vertex *cube, int x, int y, int z, int is_text) {
  int i = 0;
  int a = 0;
  x *= CHUNK_LENGTH;
  y *= CHUNK_LENGTH;
  z *= CHUNK_LENGTH;

  pthread_t thread_id[24];
  for (int y2 = y - CHUNK_RADIUS_H * CHUNK_LENGTH;
       y2 <= y + CHUNK_RADIUS_H * CHUNK_LENGTH; y2 += CHUNK_LENGTH) {

    for (int x2 = x - CHUNK_RADIUS_H * CHUNK_LENGTH;
         x2 <= x + CHUNK_RADIUS_H * CHUNK_LENGTH; x2 += CHUNK_LENGTH) {

      for (int z2 = z - CHUNK_RADIUS_V * CHUNK_LENGTH;
           z2 <= z + CHUNK_RADIUS_V * CHUNK_LENGTH; z2 += CHUNK_LENGTH) {

        VertexI pos = {{x2, y2, z2}};
        struct args args = {cube, pos, is_text, a, i};

        gen_chunk((void *)&args);

        i += CHUNK_LENGTH * CHUNK_LENGTH * CHUNK_LENGTH * 18;

        /* buggy
        pthread_create(&(thread_id[i]), NULL, gen_chunk, (void *)&args);

        if (i == 23) {
          for (int k = 0; k < 24; k++) {
            pthread_join((thread_id[k]), NULL);
          }
          i = 0;
        } else {
          i++;
        }
        */

        a++;
      }
    }
  }
}