// Copyright (c) 2021 Dominic Msters
// 
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT

#include "glfwclient.hpp"

static GLFWEngine *engine;

GLFWEngine::GLFWEngine(char **args, int32_t argc) {
  this->args = args;
  this->argc = argc;
  this->window = NULL;
}

int32_t GLFWEngine::init(void) {
  if(!glfwInit()) return 1;

  // Setup window hints 
  glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, false);

  // Create Window
  this->window = glfwCreateWindow(
    WINDOW_WIDTH_DEFAULT, WINDOW_HEIGHT_DEFAULT, this->game.name, NULL, NULL
  );
  if(!this->window) {
    glfwTerminate();
    return 1;
  }
  
  // Load GLAD
  glfwMakeContextCurrent(window);
  glfwSwapInterval(0);
  gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);

  // Init the game
  this->game.init();

  // Init the render resolution
  this->game.render.setResolution(WINDOW_WIDTH_DEFAULT, WINDOW_HEIGHT_DEFAULT);

  // Bind initial keys
  this->game.input.bind(glfwGetInputSourceForKey(GLFW_KEY_ESCAPE), INPUT_NULL);
  // input = &this->game.input;
  // inputBind(input, INPUT_NULL,          glfwGetInputSourceForKey(GLFW_KEY_ESCAPE));
  // inputBind(input, INPUT_UP,            glfwGetInputSourceForKey(GLFW_KEY_UP));
  // inputBind(input, INPUT_DOWN,          glfwGetInputSourceForKey(GLFW_KEY_DOWN));
  // inputBind(input, INPUT_LEFT,          glfwGetInputSourceForKey(GLFW_KEY_LEFT));
  // inputBind(input, INPUT_RIGHT,         glfwGetInputSourceForKey(GLFW_KEY_RIGHT));
  // inputBind(input, INPUT_UP,            glfwGetInputSourceForKey(GLFW_KEY_W));
  // inputBind(input, INPUT_DOWN,          glfwGetInputSourceForKey(GLFW_KEY_S));
  // inputBind(input, INPUT_LEFT,          glfwGetInputSourceForKey(GLFW_KEY_A));
  // inputBind(input, INPUT_RIGHT,         glfwGetInputSourceForKey(GLFW_KEY_D));
  // inputBind(input, INPUT_ACCEPT,        glfwGetInputSourceForKey(GLFW_KEY_E));
  // inputBind(input, INPUT_ACCEPT,        glfwGetInputSourceForKey(GLFW_KEY_ENTER));
  // inputBind(input, INPUT_ACCEPT,        glfwGetInputSourceForKey(GLFW_KEY_SPACE));

  // Bind the fake inputs
  this->game.input.bind(GLFW_PLATFORM_INPUT_MOUSE_X, INPUT_MOUSE_X);
  this->game.input.bind(GLFW_PLATFORM_INPUT_MOUSE_Y, INPUT_MOUSE_Y);

  // Set up some GLFW callbacks
  glfwSetWindowSizeCallback(window, &glfwOnResize);
  glfwSetKeyCallback(window, &glfwOnKey);
  glfwSetErrorCallback(&glfwOnError);
  glfwSetCursorPosCallback(window, &glfwOnCursor);
  glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
  glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
  // glfwSetWindowTitle(window, game->engine.name);


  return 0;
}

int32_t GLFWEngine::update(float delta) {
  int32_t ret;

  ret = this->game.update(delta);
  if(ret != 0) return ret;

  if(this->game.input.isPressed(INPUT_NULL)) return 1;

  return 0;
}

GLFWEngine::~GLFWEngine(void) {
  glfwSetWindowSizeCallback(window, NULL);
  glfwTerminate();
}


int32_t main(int32_t argc, char **args) {
  int32_t ret;
  double time, newTime;
  float fDelta;

  // Init engine
  engine = new GLFWEngine(args, argc);
  ret = engine->init();
  if(ret != 0) return ret;

  printf("Game is %zu bytes.\n", sizeof(engine));

  // Main Render Loop 
  while(!glfwWindowShouldClose(engine->window)) {
    glfwPollEvents();

    // Determine the delta.
    newTime = glfwGetTime();
    fDelta = (float)(newTime - time);
    time = newTime;

    ret = engine->update(fDelta);

    // Tick the engine.
    glfwSwapBuffers(engine->window);
    sleep(0);

    if(ret != 0) break;
  }

  // Cleanup the engine.
  delete engine;

  return 0;
}

void glfwOnResize(GLFWwindow *window, int32_t width, int32_t height) {
  engine->game.render.setResolution((float)width, (float)height);
}

void glfwOnKey(GLFWwindow *window,
  int32_t key, int32_t scancode, int32_t action, int32_t mods
) {
  if(action == GLFW_PRESS) {
    engine->game.input.setValue(glfwGetInputSourceForKey(key), 1.0f);
  } else if(action == GLFW_RELEASE) {
    engine->game.input.setValue(glfwGetInputSourceForKey(key), 0.0f);
  }
}

void glfwOnError(int error, const char* description) {
  fputs(description, stderr);
}

void glfwOnCursor(GLFWwindow *window, double x, double y) {
  engine->game.input.setValue(GLFW_PLATFORM_INPUT_MOUSE_X, (float)x);
  engine->game.input.setValue(GLFW_PLATFORM_INPUT_MOUSE_Y, (float)y);
}

inputsource_t glfwGetInputSourceForKey(int32_t key) {
  return (inputsource_t)((
    key <= GLFW_KEY_GRAVE_ACCENT ? key - GLFW_KEY_SPACE :
    key <= GLFW_KEY_MENU ? key - GLFW_KEY_ESCAPE + GLFW_KEY_GRAVE_ACCENT :
    key
  ) % 0xFF);
}