#include <vector>
#include "Map.hpp"

Map::Map(GameRenderer *renderer, int tile_size) :
    renderer(renderer),
    tile_size(tile_size),
    tiles(renderer->screen_width / tile_size, std::vector(renderer->screen_height / tile_size, grass)),
    tile_offset_x(-renderer->screen_width / tile_size / 2),
    tile_offset_y(-renderer->screen_height / tile_size / 2)
{
    grass_sprite = renderer->load_sprite("./assets/grass_tile.png", tile_size, tile_size);
    path_sprite = renderer->load_sprite("./assets/path_tile.png", tile_size, tile_size);

    int y = renderer->screen_height / tile_size / 2;
    for (int x = 0; x < tiles.size(); x++) {
        if (rand() % 2 == 0) y += rand() % 3 - 1;

        tiles[x][y] = path;
    }

    int x = renderer->screen_width / tile_size / 2;
    for (int y = 0; y < tiles[x].size(); y++) {
        if (rand() % 2 == 0) x += rand() % 3 - 1;

        tiles[x][y] = path;
    }
}

std::vector<Tile> Map::generate_tiles(std::vector<Tile> prev_tiles) const
{
    std::vector<Tile> new_tiles;

    for (int i = 0; i < prev_tiles.size(); i++) {
        Tile new_tile = grass;

        if (
            (i > 0 && prev_tiles[i-1] == path) ||
            prev_tiles[i] == path ||
            (i < prev_tiles.size() - 1 && prev_tiles[i+1]) == path
        ) {
            if (rand() % 2 == 0) {
                new_tile = path;
            }
        }

        new_tiles.push_back(new_tile);
    }

    return new_tiles;
}

void Map::check_bounds(int player_x, int player_y)
{
    if (tile_offset_x * tile_size + renderer->screen_width > player_x) {
        const std::vector<Tile> new_tiles = generate_tiles(tiles[0]);
        tiles.insert(tiles.begin(), new_tiles);
        tile_offset_x--;
    }

    if (tile_offset_y * tile_size + renderer->screen_height > player_y) {
        std::vector<Tile> prev_tiles;
        for (int x = 0; x < tiles.size(); x++) {
            prev_tiles.push_back(tiles[x][0]);
        }

        const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
        for (int x = 0; x < tiles.size(); x++) {
            tiles[x].insert(tiles[x].begin(), new_tiles[x]);
        }

        tile_offset_y--;
    }
}

void Map::draw(int player_x, int player_y) const
{
    for (int tile_x = 0; tile_x < tiles.size(); tile_x++) {
        for (int tile_y = 0; tile_y < tiles[tile_x].size(); tile_y++) {
            int screen_x = tile_x * tile_size + tile_offset_x * tile_size + renderer->screen_width / 2 - player_x;
            int screen_y = tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2 - player_y;

            if (
                screen_x < -tile_size || screen_y < -tile_size ||
                screen_x > renderer->screen_width || screen_y > renderer->screen_height
            ) {
                continue;
            }

            switch (tiles[tile_x][tile_y]) {
                case grass: renderer->draw_sprite(grass_sprite, screen_x, screen_y); break;
                case path:  renderer->draw_sprite(path_sprite,  screen_x, screen_y); break;
            }
        }
    }
}