#include <GL/glew.h>
#include <SDL3/SDL.h>
#include <SDL3/SDL_surface.h>
#include <stdlib.h>

#include "SDL3/SDL_events.h"
#include "SDL3/SDL_keycode.h"
#include "SDL3/SDL_surface.h"
#include "SDL3_image/SDL_image.h"
#include "camera.h"
#include "shader.h"
#include "window.h"

#include "arena_allocator.h"
#include "mesh.h"

/*
void test_task(void *data) {
  printf("\ttest task has been run: %s\n", (char *)data);
}
int main(int argc, char *argv[]) {
  // arena allocation test
  printf("Allocation test\n");
  Arena *global_arena = arena_init(NULL, 0);
  for (int i = 0; i <= 1048576 + 100; i++) {
    int *number = arena_alloc(global_arena, sizeof(int));
    *number = 42;
  }

  // arena children test
  printf("children test\n");
  Arena *child_arena = arena_init(global_arena, 0);
  Arena *sibling_arena = arena_init(global_arena, 0);
  Arena *grandchild_arena = arena_init(child_arena, 0);
  Arena *greatgrandchild_arena = arena_init(grandchild_arena, 0);
  Arena *greatgrandchildsibling_arena = arena_init(grandchild_arena, 0);
  Arena *greatgrandchildsiblingsibling_arena = arena_init(grandchild_arena, 0);
  Arena *greategreatgrandchild_arena =
      arena_init(greatgrandchildsibling_arena, 0);
  Arena *greatsiblinggreatgrandchild_arena =
      arena_init(greatgrandchildsiblingsibling_arena, 0);

  printf("deinit task creation tests\n");

  ArenaDeinitTask task = {NULL};
  task.func_ptr = *test_task;
  task.func_param = "parameter";

  arena_deinit_task_push(global_arena, task);

  task.func_param = "2nd parameter added";
  arena_deinit_task_push(global_arena, task);

  printf("deinit tests\n");
  arena_deinit(greatgrandchild_arena);

  arena_deinit(global_arena);

  printf("tests complete\n");
}
*/

int main(int argc, char *argv[]) {
  Arena *global_arena = arena_init(NULL, 0);

  wn_window *window = wn_window_init(global_arena);
  if (window == NULL) {
    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize wn_window");
    return EXIT_FAILURE;
  }
  wn_shader_code_location shader_code_location = {
      .vertex_shader_source_path = "shaders/vert.glsl",
      .fragment_shader_source_path = "shaders/frag.glsl"};

  wn_shader *shader = wn_shader_init(global_arena, shader_code_location);
  if (shader->success == false) {
    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize shader");
    return EXIT_FAILURE;
  }

// Set up mesh data
  float vertices[] = {
      0.5f,  0.5f,  0.0f, 1.0f, 1.0f, // top right
      0.5f,  -0.5f, 0.0f, 1.0f, 0.0f, // bottom right
      -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, // bottom left
      -0.5f, 0.5f,  0.0f, 0.0f, 1.0f  // top left
  };
  unsigned int indices[] = {
      0, 1, 3, // first Triangle
      1, 2, 3  // second Triangle
  };

  // Create mesh
  wn_mesh *mesh = wn_mesh_init(global_arena, vertices, 20, indices, 6, "./data/testxure.png");
  if (mesh == NULL) {
    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize mesh");
    return EXIT_FAILURE;
  }

  // Initialise camera
  Camera camera = Camera_default;

  // set our texture uniform
  glUseProgram(shader->shaderProgram);
  glUniform1i(glGetUniformLocation(shader->shaderProgram, "ourTexture"), 0);

  bool wants_running = true;
  while (wants_running) {
    // TODO: Create event handler files
    while (SDL_PollEvent(&window->event)) {
      switch (window->event.type) {
      case SDL_EVENT_QUIT:
        wants_running = false;
        break;
      case SDL_EVENT_KEY_DOWN:
        if (window->event.key.key == SDLK_ESCAPE) {
          wants_running = false;
        }
        break;
      }
    }

    // Handle camera
    camera_tick(&camera);

    // TODO: make shader handler
    mat4 mvp;
    camera_calc_mvp(&mvp, &camera);
    int mvp_uniform_location =
        glGetUniformLocation(shader->shaderProgram, "MVP");
    glUniformMatrix4fv(mvp_uniform_location, 1, GL_FALSE, &mvp[0][0]);

    // render
    glClearColor(0.1f, 0.3f, 0.4f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT);

    // draw our mesh
    glUseProgram(shader->shaderProgram);
    wn_mesh_draw(mesh);

    wn_swapwindow(window);
  }

  // Mesh cleanup is handled by arena deinit tasks

  arena_deinit(global_arena);
  return EXIT_SUCCESS;
}