#include <stdio.h>
#include <raylib.h>
#include <cute_tiled.h>
#include <flecs.h>
#include <breeze.h>
#include "world/tileset.h"

static void drawTile(Texture2D texture, int tid, int tileSetWidth, int size, Vector2 pos) {
    Rectangle rec = {(tid % tileSetWidth) * size, (tid / tileSetWidth) * size, size, size};

    DrawTextureRec(texture, rec, pos, WHITE);
}

static void drawLayer(cute_tiled_layer_t *layer, Tileset *tileset) {
    Vector2 pos = {layer->offsetx, layer->offsety};

    for (int y = 0; y < layer->height; y++) {
        for (int x = 0; x < layer->width; x++) {
            int tile = layer->data[y * layer->width + x];
            if (tile - tileset->startID != -1) {
                Rectangle rec = tilesetGetTileRegion(tileset, tile);
                DrawTextureRec(tileset->tiles, rec, pos, WHITE);
            }
            pos.x += tileset->tileWidth;
        }
        pos.x = layer->offsetx;
        pos.y += tileset->tileHeight;
    }
}

int main(void) {

    const int screenWidth = 1280;
    const int screenHeight = 720;

    InitWindow(screenWidth, screenHeight, "PixelDefense");
    SetTargetFPS(60);

    cute_tiled_map_t* map = cute_tiled_load_map_from_file("assets/maps/test.tmj", NULL);

    cute_tiled_tileset_t *terrainSource = cute_tiled_load_external_tileset("assets/terrain.tsj", NULL);
    cute_tiled_tileset_t *buildingsSource = cute_tiled_load_external_tileset("assets/buildings.tsj", NULL);

    Tileset terrainTileset = tilesetCreate( &(TilesetDesc) {
        .source=terrainSource,
        .assetDir="assets"
    });
    Tileset buildingsTileset = tilesetCreate(&(TilesetDesc) {
        .source=buildingsSource,
        .assetDir="assets"
    });

    cute_tiled_tileset_t *tileset = map->tilesets;
    terrainTileset.startID = tileset->firstgid;
    tileset = tileset->next;
    buildingsTileset.startID = tileset->firstgid;

    cute_tiled_free_external_tileset(terrainSource);
    cute_tiled_free_external_tileset(buildingsSource);



    cute_tiled_layer_t *terrain = NULL;
    cute_tiled_layer_t *trees = NULL;
    cute_tiled_layer_t *trees2 = NULL;
    cute_tiled_layer_t *buildings = NULL;
    // loop over the map's layers
    cute_tiled_layer_t* layer = map->layers;
    while (layer)
    {
        int* data = layer->data;
        int data_count = layer->data_count;

        if (strcmp("Terrain", layer->name.ptr) == 0) {
            terrain = layer;
        } else if (strcmp("Foliage", layer->name.ptr) == 0) {

        } else if (strcmp("Trees", layer->name.ptr) == 0) {
            trees = layer;
        } else if (strcmp("TreesS", layer->name.ptr) == 0) {
            trees2 = layer;
        } else if (strcmp("Buildings", layer->name.ptr) == 0) {
            buildings = layer;
        }

        layer = layer->next;
    }

    Camera2D camera = { 0 };
    camera.target = (Vector2) {0, 0};
    camera.offset = (Vector2) {screenWidth / 2.0f, screenHeight / 2.0f};
    camera.rotation = 0.0f;
    camera.zoom = 1.0f;



    while (!WindowShouldClose()) {
        if (IsKeyPressed(KEY_ESCAPE)) {
            break;
        }

        if (IsKeyDown(KEY_W)) camera.target.y -= 20;
        if (IsKeyDown(KEY_S)) camera.target.y += 20;
        if (IsKeyDown(KEY_A)) camera.target.x -= 20;
        if (IsKeyDown(KEY_D)) camera.target.x += 20;

        if (IsKeyDown(KEY_Q)) camera.rotation--;
        if (IsKeyDown(KEY_E)) camera.rotation++;

        camera.zoom += ((float)GetMouseWheelMove()*0.05f);

        BeginDrawing();
        BeginMode2D(camera);
        ClearBackground(RAYWHITE);

        drawLayer(terrain, &terrainTileset);
        drawLayer(trees, &terrainTileset);
        drawLayer(trees2, &terrainTileset);
        drawLayer(buildings, &buildingsTileset);

        EndMode2D();
        EndDrawing();

    }

    tilesetDestroy(&terrainTileset);
    tilesetDestroy(&buildingsTileset);
    cute_tiled_free_map(map);

    CloseWindow();

    return 0;
}