#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, Tile::grass)),
    tile_offset_x(-renderer->screen_width / tile_size / 2.0),
    tile_offset_y(-renderer->screen_height / tile_size / 2.0)
{
    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);

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

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

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

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

std::vector<Tile> Map::generate_tiles(const std::vector<Tile> &prev_tiles) const
{
    std::vector<Tile> new_tiles = std::vector(prev_tiles.size(), Tile::grass);

    int path_idx = 0;
    for (unsigned int i = 0; i < prev_tiles.size(); i++) {
        if (prev_tiles[i] == Tile::path) path_idx = i;
    }

    if (rand() % 2 == 0) path_idx += rand() % 3 - 1;

    new_tiles[path_idx] = Tile::path;

    return new_tiles;
}

void Map::check_bounds(const double player_x, const double player_y)
{
    // Generate to the left
    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--;
    }

    // Generate upwards
    if (tile_offset_y * tile_size + renderer->screen_height > player_y) {
        std::vector<Tile> prev_tiles;
        for (unsigned 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 (unsigned int x = 0; x < tiles.size(); x++) {
            tiles[x].insert(tiles[x].begin(), new_tiles[x]);
        }

        tile_offset_y--;
    }

    // Generate to the right
    if (player_x > tile_offset_x * tile_size + tiles.size() * tile_size - renderer->screen_width / 2) {
        const std::vector<Tile> new_tiles = generate_tiles(tiles.back());
        tiles.push_back(new_tiles);
    }

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

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

void Map::draw(const double player_x, const double player_y) const
{
    for (unsigned int tile_x = 0; tile_x < tiles.size(); tile_x++) {
        for (unsigned int tile_y = 0; tile_y < tiles[tile_x].size(); tile_y++) {
            int screen_x = (int)(tile_x * tile_size + tile_offset_x * tile_size + renderer->screen_width / 2.0 - player_x);
            int screen_y = (int)(tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2.0 - 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 Tile::grass: renderer->draw_sprite(grass_sprite, screen_x, screen_y); break;
                case Tile::path:  renderer->draw_sprite(path_sprite,  screen_x, screen_y); break;
            }
        }
    }
}