#include "twn_draw.h"
#include "twn_draw_c.h"
#include "twn_engine_context_c.h"
#include "twn_textures_c.h"
#include "twn_types.h"

#include <stb_ds.h>


/* TODO: automatic handling of repeating textures */
/*       for that we could allocate a loner texture */
void draw_triangle(const char *path,
                   Vec3 v0,
                   Vec3 v1,
                   Vec3 v2,
                   Vec2 uv0,
                   Vec2 uv1,
                   Vec2 uv2)
{
    // TODO: order drawing by atlas id as well, so that texture rebinding is not as common
    const TextureKey texture_key = textures_get_key(&ctx.texture_cache, path);

    struct MeshBatchItem *batch_p = hmgetp_null(ctx.uncolored_mesh_batches, texture_key);
    if (!batch_p) {
        struct MeshBatch item = {0};
        hmput(ctx.uncolored_mesh_batches, texture_key, item);
        batch_p = &ctx.uncolored_mesh_batches[hmlenu(ctx.uncolored_mesh_batches) - 1];
    }

    UncoloredSpaceTriangle const triangle = {
        .v0 = v0,
        .v1 = v1,
        .v2 = v2,
        .uv1 = uv1,
        .uv0 = uv0,
        .uv2 = uv2,
    };

    UncoloredSpaceTriangle *triangles = (UncoloredSpaceTriangle *)(void *)batch_p->value.primitives;

    arrpush(triangles, triangle);
    batch_p->value.primitives = (uint8_t *)triangles;
}


void finally_draw_uncolored_space_traingle_batch(const MeshBatch *batch,
                                                 const TextureKey texture_key)
{
    const size_t primitives_len = arrlenu(batch->primitives);

    /* nothing to do */
    if (primitives_len == 0)
        return;

    VertexBuffer const buffer = get_scratch_vertex_array();

    const Rect srcrect = textures_get_srcrect(&ctx.texture_cache, texture_key);
    const Rect dims    = textures_get_dims(&ctx.texture_cache, texture_key);

    const float wr = srcrect.w / dims.w;
    const float hr = srcrect.h / dims.h;
    const float xr = srcrect.x / dims.w;
    const float yr = srcrect.y / dims.h;

    /* update pixel-based uvs to correspond with texture atlases */
    for (size_t i = 0; i < primitives_len; ++i) {
        UncoloredSpaceTriangle *payload =
            &((UncoloredSpaceTriangle *)(void *)batch->primitives)[i];

        payload->uv0.x = xr + ((float)payload->uv0.x / srcrect.w) * wr;
        payload->uv0.y = yr + ((float)payload->uv0.y / srcrect.h) * hr;
        payload->uv1.x = xr + ((float)payload->uv1.x / srcrect.w) * wr;
        payload->uv1.y = yr + ((float)payload->uv1.y / srcrect.h) * hr;
        payload->uv2.x = xr + ((float)payload->uv2.x / srcrect.w) * wr;
        payload->uv2.y = yr + ((float)payload->uv2.y / srcrect.h) * hr;
    }

    specify_vertex_buffer(buffer, batch->primitives, primitives_len * sizeof (UncoloredSpaceTriangle));

    DeferredCommandDraw command = {0};

    command.vertices = (AttributeArrayPointer) {
        .arity = 3,
        .type = GL_FLOAT,
        .stride = offsetof(UncoloredSpaceTriangle, v1),
        .offset = offsetof(UncoloredSpaceTriangle, v0),
        .buffer = buffer
    };

    command.texcoords = (AttributeArrayPointer) {
        .arity = 2,
        .type = GL_FLOAT,
        .stride = offsetof(UncoloredSpaceTriangle, v1),
        .offset = offsetof(UncoloredSpaceTriangle, uv0),
        .buffer = buffer
    };

    command.textured = true;
    command.texture_key = texture_key;

    command.primitive_count = (GLsizei)(3 * primitives_len);

    /* TODO: support alpha blended case, with distance sort */
    TextureMode mode = textures_get_mode(&ctx.texture_cache, texture_key);
    if (mode == TEXTURE_MODE_GHOSTLY)
        mode = TEXTURE_MODE_SEETHROUGH;
    use_texture_mode(mode);

    DeferredCommand final_command = {
        .type = DEFERRED_COMMAND_TYPE_DRAW,
        .draw = command
    };

    arrpush(deferred_commands, final_command);
}