#include <renderer/Renderer.hpp>
#include <renderer/RSoftwareBackend.hpp>

#include <GL/glew.h>
#include <imgui.h>

#include <memory>


Renderer g_renderer;


void
Renderer::Init(SDL_Window* window)
{
    m_window = window;
    m_render_entities.reserve(1024);
    m_sort_entries.reserve(1024);
    m_backend = std::make_unique<RSoftwareBackend>(*this);
}

void
Renderer::Reset()
{
    m_render_entities.clear();
    m_sort_entries.clear();
    SetCameraSize(0.0f, 0.0f);
}

void
Renderer::Draw()
{
    m_backend->Draw();
}

void
Renderer::SetScreenSize(int32_t w, int32_t h)
{
    m_screen_w = w;
    m_screen_h = h;
}

void
Renderer::SetCameraSize(float w, float h)
{
    m_camera_w = w;
    m_camera_h = h;
}

int32_t
Renderer::WorldXToScreenX(float world_x)
{
    float screen_x = (world_x / m_camera_w) * (float)m_screen_w;
    return (int32_t)screen_x;
}

int32_t
Renderer::WorldYToScreenY(float world_y)
{
    float screen_y = (world_y / m_camera_h) * (float)m_screen_h;
    return (int32_t)screen_y;
}

void
Renderer::Clear(Color color)
{
    Rectangle rect = {
        0.0f,
        0.0f,
        m_camera_w,
        m_camera_h
    };
    PushRectangle(rect, color, -1.0f);
}

void
Renderer::PushAlphaBitmap(AlphaBitmap& bitmap, V3F32 pos, Color color)
{
    m_render_entities.emplace_back(REntity{.bitmap{
            REntityType_AlphaBitmap,
            bitmap,
            pos,
            color
    }});
    m_sort_entries.emplace_back(pos.z, m_render_entities.size()-1);
}

void
Renderer::PushRectangle(Rectangle rect, Color color, float z)
{
    m_render_entities.emplace_back(REntity{.rect{
            REntityType_Rectangle,
            rect,
            color
    }});
    m_sort_entries.emplace_back(z, m_render_entities.size()-1);
}

void
Renderer::PushCircle(Circle circle, Color color, float z)
{
    m_render_entities.emplace_back(REntity{.circle{
            REntityType_Circle,
            circle,
            color
    }});
    m_sort_entries.emplace_back(z, m_render_entities.size()-1);
}

void
Renderer::PushText(std::u32string& text, Font& font, V3F32 pos, Color color)
{
    m_render_entities.emplace_back(REntity{.text{
            REntityType_Text,
            text,
            font,
            pos,
            color
    }});
    m_sort_entries.emplace_back(pos.z, m_render_entities.size()-1);
}


/* temporary helper functions (from old RGroup api) */

float
Renderer::GetScale()
{
    float screen_width = static_cast<float>(m_screen_w);
    float screen_height = static_cast<float>(m_screen_h);
    float xunits = screen_width / m_camera_w;
    float yunits = screen_height / m_camera_h;
    float scale = std::min(xunits, yunits);
    return scale;
}

V2F32
Renderer::ViewPosToScreenPos(V2F32 view_pos)
{
    float scale = GetScale();
    float screen_width = static_cast<float>(m_screen_w);
    float screen_height = static_cast<float>(m_screen_h);
    float viewport_width = m_camera_w * scale;
    float viewport_height = m_camera_h * scale;
    float viewport_x0 = (screen_width - viewport_width) / 2;
    float viewport_y0 = (screen_height - viewport_height) / 2;

    V2F32 result;
    result.x = viewport_x0 + view_pos.x * scale;
    result.y = screen_height - (viewport_y0 + view_pos.y * scale);

    return result;
}

V2F32
Renderer::ViewSizeToScreenSize(V2F32 view_size)
{
    float scale = GetScale();

    V2F32 result;
    result.x = view_size.x * scale;
    result.y = view_size.y * scale;

    return result;
}

ImVec2
Renderer::ViewPosToScreenPosImGui(V2F32 view_pos)
{
    V2F32 screen_pos = ViewPosToScreenPos(view_pos);
    ImVec2 result = {screen_pos.x, screen_pos.y};
    return result;
}

ImVec2
Renderer::ViewSizeToScreenSizeImGui(V2F32 view_size)
{
    V2F32 screen_size = ViewSizeToScreenSize(view_size);
    ImVec2 result = {screen_size.x, screen_size.y};
    return result;
}