#include "include/glad/glad.h"
#include <GLFW/glfw3.h>
#include <cstddef>
#include <initializer_list>
#include <iostream>
#include <exception>
#include <string_view>
#include <string>
#include <memory>


class BufferObject {
 public:
  BufferObject(size_t n, GLenum target, size_t size, const void *data, GLenum usage) {
    glGenBuffers(n, &buffer_id);
    glBindBuffer(target, buffer_id);
    glBufferData(target, size, data, usage);
  }

  unsigned int get_vbo_id() const {
    return buffer_id;
  }

 private:
  unsigned int buffer_id;
};


class VAObject {
  public:
    explicit VAObject(size_t n) {
      glGenVertexArrays(n, &vao_id);
    }

  void bind_vao() const {
    glBindVertexArray(vao_id);
  }

  unsigned int get_vao_id() const {
    return vao_id;
  }

  private:
    unsigned int vao_id;
};


class GLShader {
  friend class GLShaderProgram;
 public:
  GLShader(const char **src, size_t count, GLenum shader_type, int *length) {
    shader_id = glCreateShader(shader_type);
    glShaderSource(shader_id, count, src, length);
    glCompileShader(shader_id);
    glGetShaderiv(shader_id, GL_COMPILE_STATUS, &compile_status);
  }

  int get_compile_status() const {
    return compile_status;
  }

  unsigned int get_shader_id() const {
    return shader_id;
  }

  ~GLShader() {
    glDeleteShader(shader_id);
  }

  void get_shader_infolog() const {
    char *log;
    glGetShaderInfoLog(shader_id, 512, NULL, log);
    std::cout << log << std::endl;
  }

 private:
  unsigned int shader_id;
  int compile_status;
};


class GLShaderProgram {
 public:
  GLShaderProgram(std::initializer_list<std::shared_ptr<GLShader>> shaders) {
    shader_program_id = glCreateProgram();

    for (auto shader : shaders)
      glAttachShader(shader_program_id, shader->get_shader_id());

    for (auto shader : shaders)
      shader.reset();
  }

  void link_program() {
    glLinkProgram(shader_program_id);
  }

  void bind_attribute_location(int location, const char *attr) {
    glBindAttribLocation(shader_program_id, location, attr);
  }

  void use_shader_program() const {
    glUseProgram(shader_program_id);
  }

 private:
  unsigned int shader_program_id;
};


class GLFWInitFailed: public std::exception {
 public:
  GLFWInitFailed(int err_code, const char *msg) {
    full_error_message = "[" + std::to_string(err_code) + "] " + std::string(msg);
  }

  const char *what() const noexcept override {
    return full_error_message.c_str();
  }

 private:
  std::string full_error_message;
};


void error_callback(int err_code, const char *err_msg);


void framebuffer_size_callback(GLFWwindow *window, int width, int height);


class GLFWWindow {
  friend void error_callback(int err_code, const char *err_msg);
  friend void framebuffer_size_callback(GLFWwindow *window, size_t width, size_t height);
 public:
  GLFWWindow(size_t width, size_t height, const char *title, GLFWmonitor *monitor, GLFWwindow *share,
             int version_major, int version_minor, int profile);

  ~GLFWWindow() {
    glfwTerminate();
  }

  GLFWWindow(const GLFWWindow &rhs) = delete;
  GLFWWindow &operator=(const GLFWWindow &rhs) = delete;

  void set_viewport(int x, int y, size_t width, size_t height) {
    glViewport(x, y, width, height);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    viewport_x = x;
    viewport_y = y;
  }

  void main_loop_setup() {
    glfwSwapBuffers(window);
    glfwPollEvents();
  }

  void get_gl_string(GLenum name) {
    std::cout << glGetString(name) << std::endl;
  }

  bool should_close() {
    return glfwWindowShouldClose(window);
  }

  void set_close() {
    glfwSetWindowShouldClose(window, true);
  }

  void set_color(float r, float g, float b, float a) {
    glClearColor(r, g, b, a);
  }

  void clear_buffer(GLbitfield mask) {
    glClear(mask);
  }

  int get_event(int key) {
    return glfwGetKey(window, key);
  }

  static int viewport_x;
  static int viewport_y;

 private:
  GLFWwindow *window;
};