#include "primitive_internals.h"
#include "deerith/graphics/primitive.h"
#include "deerith/graphics/shader.h"
#include "deerith/graphics/mesh.h"

#include "glm/glm.hpp"
#include "glm/mat4x4.hpp"
#include "glm/ext/matrix_clip_space.hpp"
#include <glm/gtc/matrix_transform.hpp>

#include <glm/gtc/type_ptr.hpp>
#include <deerith/core/log.h>
#include <memory>

#include <glad/gl.h>

namespace deerith
{
    std::unique_ptr<Shader> primitive_shader;
    std::unique_ptr<Mesh2D> primitive_rectangle_mesh;
}

void deerith::init_primitives()
{
    primitive_shader = std::make_unique<Shader>(
        "../deerith_engine_client/shaders/primitive.vert.glsl",
        "../deerith_engine_client/shaders/primitive.frag.glsl");

    primitive_rectangle_mesh = std::make_unique<Mesh2D>(rectangle_vertices, 4, rectangle_indices, 6);
}

void deerith::shutdown_primitives()
{
    primitive_shader.release();
    primitive_shader.reset();
    primitive_rectangle_mesh.release();
    primitive_rectangle_mesh.reset();
}

void deerith::define_primitive_viewspace(glm::vec2 start_viewspace, glm::vec2 end_viewspace)
{
    float width = end_viewspace.x - start_viewspace.x;
    float height = end_viewspace.y - start_viewspace.y;

    deerith_client_assert(width > 0, "define_primitive_viewspace width must be > 0");
    deerith_client_assert(height > 0, "define_primitive_viewspace height must be > 0");

    glm::mat4 m_projection = glm::ortho(
        start_viewspace.x,
        end_viewspace.x,
        start_viewspace.y,
        end_viewspace.y,
        -1.0f,
        1.0f);

    primitive_shader->set_matrix("uViewProjection", m_projection);
}

void deerith::define_primitive_color(glm::vec4 color)
{
    primitive_shader->set_vec4("uColor", color);
}

void deerith::draw_primitive_rectangle(glm::vec2 start, glm::vec2 end)
{
    float width = end.x - start.x;
    float height = end.y - start.y;

    deerith_client_assert(width > 0, "draw_primitive_rectangle width must be > 0");
    deerith_client_assert(height > 0, "draw_primitive_rectangle height must be > 0");

    glm::mat4 model = glm::translate(glm::mat4(1), glm::vec3(start.x, start.y, 0.0f));
    model = glm::scale(model, glm::vec3(width, height, 1.0f));

    primitive_shader->use();
    primitive_shader->set_matrix("uTransform", model);
    primitive_rectangle_mesh->draw();
}