#include <cute_tiled.h>
#include <stdio.h>

#include "tileset.h"
#include "../core/memory.h"

BzTileset BZ_TILESET_INVALID = {.isValid = false};

BzTileset bzTilesetCreate(const BzTilesetDesc *desc) {
    BzTileset tileset = {};
    cute_tiled_tileset_t *cuteTileset = cute_tiled_load_external_tileset(desc->path, NULL);

    tileset.tiles = LoadTexture(desc->texturePath);
    tileset.startID = cuteTileset->firstgid;
    tileset.tileWidth = cuteTileset->tilewidth;
    tileset.tileHeight = cuteTileset->tileheight;

    tileset.offsetX = cuteTileset->tileoffset_x;
    tileset.offsetY = cuteTileset->tileoffset_y;

    tileset.width = tileset.tiles.width / tileset.tileWidth;
    tileset.height = tileset.tiles.height / tileset.tileHeight;

    tileset.tileCount = tileset.width * tileset.tileHeight;
    tileset.tileColliders = bzAlloc(tileset.tileCount * sizeof(*tileset.tileColliders));
    for (i32 i = 0; i < tileset.tileCount; i++) {
        tileset.tileColliders[i] = (BzTileCollider) {BZ_TILE_COLLIDER_NONE};
    }

    cute_tiled_tile_descriptor_t *cuteTile = cuteTileset->tiles;
    while (cuteTile) {
        if (!cuteTile->objectgroup) break;
        cute_tiled_object_t *cuteObject = cuteTile->objectgroup->objects;
        // NOTE: Only supporting single collider (integer values)
        if (cuteObject) {
            if (cuteObject->vertices) break;

            BzTileCollider collider = {BZ_TILE_COLLIDER_RECT};
            if (cuteObject->ellipse)
                collider.type = BZ_TILE_COLLIDER_ELLIPSE;
            collider.x = (i8) cuteObject->x;
            collider.y = (i8) cuteObject->y;
            collider.sizeX = (i8) cuteObject->width;
            collider.sizeY = (i8) cuteObject->height;

            tileset.tileColliders[cuteTile->tile_index] = collider;
        }
        cuteTile = cuteTile->next;
    }

    cute_tiled_free_external_tileset(cuteTileset);

    if (tileset.tiles.width != cuteTileset->imagewidth ||
        tileset.tiles.height != cuteTileset->imageheight) {
        bzTilesetDestroy(&tileset);
        return BZ_TILESET_INVALID;
    }

    tileset.isValid = true;
    return tileset;
}

Rectangle bzTilesetGetTileRegion(BzTileset *tileset, int tileID) {
    tileID = tileID - tileset->startID;
    if (tileID < 0 || tileID >= tileset->tileCount) {
        return (Rectangle){};
    }
    int posX = tileID % tileset->width;
    int posY = tileID / tileset->width;
    return (Rectangle) {posX * tileset->tileWidth, posY * tileset->tileHeight,
                        tileset->tileWidth, tileset->tileHeight};
}
BzTileCollider bzTilesetGetTileCollider(BzTileset *tileset, int tileID) {
    tileID = tileID - tileset->startID;

    if (tileID < 0 || tileID >= tileset->tileCount) {
        return (BzTileCollider) {.type = BZ_TILE_COLLIDER_NONE};
    }

    return tileset->tileColliders[tileID];
}

void bzTilesetDestroy(BzTileset *tileset) {
    UnloadTexture(tileset->tiles);
    *tileset = BZ_TILESET_INVALID;
}