#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>

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 = 0;
  unsigned int skyboxVBO = 0;
  unsigned int skybox_texture_id = 0;
  bool reflect_on = false;

  Scene(components::Scene& config):
    shader{config.shader.vertex_path, config.shader.frag_path},
    reflect_shader{config.reflect_shader.vertex_path, config.reflect_shader.frag_path},
    skybox_shader{config.skybox_shader.vertex_path, config.skybox_shader.frag_path},
    skybox_faces{config.skybox_faces},
    screen{.shader={config.screen_shader.vertex_path, config.screen_shader.frag_path}},
    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);
    }

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

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

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

  void update();
  void draw_thing(Shader& with_shader, Thing& thing);
  void render(GLFWwindow* window);
  void cleanup();
  void spawn(const std::string& name, components::Position& position, components::Rotation& rotation);
  void init_skybox();
  void load_skybox_textures();
  void render_skybox(const glm::mat4& projection);
};