#pragma once

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include "shader.hpp"
#include "model.hpp"
#include "shader.hpp"
#include "model.hpp"
#include "camera.hpp"
#include "components.hpp"
#include "framebuffer.hpp"
#include <vector>
#include <unordered_map>
#include "config.hpp"

struct Thing {
  std::string name;
  Model& model;
  Material& material;
  components::Position position;
  components::Rotation rotation;
  float scale;
  float distance = 0;
};

struct Scene {
  Shader shader;
  Shader reflect_shader;
  Shader skybox_shader;
  std::vector<std::string> skybox_faces;
  Screen screen;
  FrameBuffer framebuffer;

  std::unordered_map<std::string, components::Material> materials;
  Camera camera;
  components::Lighting light;
  std::unordered_map<std::string, Model> models;
  std::vector<Thing> things;
  float deltaTime = 0.0f;
  float lastFrame = 0.0f;
  unsigned int skyboxVAO = UINT_MAX;
  unsigned int skyboxVBO = UINT_MAX;
  unsigned int skybox_texture_id = UINT_MAX;
  glm::mat4 projection = glm::mat4(1.0f);
  bool reflect_on = false;

  // shadow stuff
  Shader depth_shader{{"shaders/33-depth.vert.glsl", "shaders/33-depth.frag.glsl", ""}};
  Shader depth_dbg_shader{{"shaders/33-shadow_dbg.vert.glsl", "shaders/33-shadow_dbg.frag.glsl", ""}};
  unsigned int depth_FBO = UINT_MAX;
  unsigned int depth_map = UINT_MAX;
  const unsigned int SHADOW_WIDTH = 1024 * 8, SHADOW_HEIGHT = 1024 * 8;
  float near_plane = 1.0f;
  float far_plane = 100.0f;

  float depth_near_plane = 1.0f;
  float depth_far_plane = 7.5f;

  glm::mat4 light_space;
  bool debug_on = false;

  float quadVertices[20] = {
    // positions        // texture Coords
    -1.0f,  1.0f, 0.0f, 0.0f, 1.0f,
    -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
    1.0f,  1.0f, 0.0f, 1.0f, 1.0f,
    1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
  };


  unsigned int quadVAO = UINT_MAX;
  unsigned int quadVBO = UINT_MAX;

  bool shadows_rendered = false;

  Scene(components::Scene& config):
    shader{config.shader},
    reflect_shader{config.reflect_shader},
    skybox_shader{config.skybox_shader},
    skybox_faces{config.skybox_faces},
    screen{.shader={config.screen_shader}},
    materials{config.materials},
    camera{
      .position=config.camera.position,
      .front=config.camera.front,
      .up=config.camera.up,
      .direction=config.camera.direction,
      .movement_speed=config.camera.movement_speed,
    },
    light{config.light}
  {
    for(auto& [name, model] : config.models) {
      models.try_emplace(name, model.directory, model.model_path);
    }

    for(auto& thing : config.things) {
      things.emplace_back(
          thing.model,
          models.at(thing.model),
          materials.at(thing.material),
          thing.position,
          thing.rotation,
          thing.scale);
    }

    glGenVertexArrays(1, &skyboxVAO);
    glGenBuffers(1, &skyboxVBO);
    glGenTextures(1, &skybox_texture_id);

    shader.use();
    shader.setInt("texture1", 0);
    shader.apply_lighting(light);

    skybox_shader.use();
    skybox_shader.setInt("skybox", 0);

    framebuffer.init();
    screen.init();
    init_skybox();
    init_shadows();
    init_debug();
  }

  void update();
  void draw_thing(Shader& with_shader, Thing& thing);
  void render(GLFWwindow* window);
  void cleanup();
  void init_skybox();
  void init_shadows();
  void init_debug();
  void load_skybox_textures();
  void render_skybox();
  void spawn(const std::string& name);
  void render_scene(GLFWwindow* window, Shader& with_shader);
  void render_shadows(GLFWwindow* window);
  void render_debug(GLFWwindow* window);
};