#include "blocks.hpp"
#include "global_vars.hpp"
#include "objectids.hpp"
#include "sprites.hpp"
#include <unordered_map>

MarioBlock::MarioBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> renderer, std::shared_ptr<SDLPP::Texture> texture, SDL_Rect src) : RectangleRender( x * BLOCK_SIZE, 1 - (16-y) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, renderer, texture, src ) {}
void MarioBlock::visit( SDLPP::Visitor &visitor ) {
    if(!_tool && _terrain && visitor.getVisitorType() == TOOL_VISITOR_TYPE) {
        destroy();
    }
    if(!_tool && !_terrain && visitor.getVisitorType() == MODIFIER_VISITOR_TYPE) {
        destroy();
    }
    visitor.visit(*this);
}
void MarioBlock::setTool(bool tool) {
    _tool = tool;
}
void MarioBlock::setTerrain(bool terrain) {
    _terrain = terrain;
}

const std::vector< uint64_t > possibleBlocks = { FLOOR_ID,
                                                 STEP_ID,
                                                 HILL_TOP_ID,
                                                 HILL_DOTS_LEFT_ID,
                                                 HILL_FILL_ID,
                                                 HILL_INCLINE_ID,
                                                 HILL_DOTS_RIGHT_ID,
                                                 HILL_DECLINE_ID,
                                                 CLOUD_LEFT_TOP_ID,
                                                 CLOUD_MIDDLE_TOP_ID,
                                                 CLOUD_RIGHT_TOP_ID,
                                                 VINE_TOP_ID,
                                                 CLOUD_LEFT_BOTTOM_ID,
                                                 CLOUD_MIDDLE_BOTTOM_ID,
                                                 CLOUD_RIGHT_BOTTOM_ID,
                                                 VINE_BOTTOM_ID,
                                                 BRICK_TOP_ID,
                                                 BRICK_ID,
                                                 FLAG_ID,
                                                 WATER_TOP_ID,
                                                 BUSH_LEFT_ID,
                                                 BUSH_MIDDLE_ID,
                                                 BUSH_RIGHT_ID,
                                                 WATER_FILL_ID,
                                                 PIPE_LEFT_TOP_ID,
                                                 PIPE_RIGHT_TOP_ID,
                                                 CASTLE_TOWER_ID,
                                                 CASTLE_TOWER_FILLED_ID,
                                                 PIPE_LEFT_BOTTOM_ID,
                                                 PIPE_RIGHT_BOTTOM_ID,
                                                 CASTLE_LEFT_ID,
                                                 CASTLE_RIGHT_ID,
                                                 POLE_TOP_ID,
                                                 CASTLE_ENTRY_ID,
                                                 SIDEWAY_PIPE_END_TOP_ID,
                                                 SIDEWAY_PIPE_MIDDLE_TOP_ID,
                                                 POLE_BOTTOM_ID,
                                                 CASTLE_BLACK_ID,
                                                 SIDEWAY_PIPE_END_BOTTOM_ID,
                                                 SIDEWAY_PIPE_MIDDLE_BOTTOM_ID,
                                                 SIDEWAY_PIPE_CONNECTOR_TOP_ID,
                                                 TREE_PLATFORM_TOP_LEFT_ID,
                                                 TREE_PLATFORM_TOP_MIDDLE_ID,
                                                 TREE_PLATFORM_TOP_RIGHT_ID,
                                                 SIDEWAY_PIPE_CONNECTOR_BOTTOM_ID,
                                                 MUSHROOM_PLATFORM_TOP_LEFT_ID,
                                                 MUSHROOM_PLATFORM_TOP_MIDDLE_ID,
                                                 MUSHROOM_PLATFORM_TOP_RIGHT_ID,

                                                 TREE_PLATFORM_BARK_ID,
                                                 MUSHROOM_PLATFORM_BARK_TOP_ID,
                                                 TREE_LEAVES_TOP_ID,
                                                 TREE_LEAVES_SMALL_ID,
                                                 CANNON_TOWER_ID,
                                                 MUSHROOM_PLATFORM_BARK_BOTTOM_ID,
                                                 TREE_LEAVES_BOTTOM_ID,
                                                 TREE_BARK_ID,
                                                 CANNON_PEDESTAL_ID,
                                                 CANNON_ID,
                                                 MARIO_ID,
};

const std::unordered_map<uint64_t, const SDL_Rect*> block_mapping = {
    {FLOOR_ID, &FLOOR_SRC}, {HILL_INCLINE_ID, &HILL_INCLINE_SRC},
    {HILL_DECLINE_ID, &HILL_DECLINE_SRC}, {HILL_DOTS_RIGHT_ID, &HILL_DOTS_RIGHT_SRC},
    {HILL_DOTS_LEFT_ID, &HILL_DOTS_LEFT_SRC}, {HILL_FILL_ID, &HILL_FILL_SRC},
    {HILL_TOP_ID, &HILL_TOP_SRC}, {BUSH_LEFT_ID, &BUSH_LEFT_SRC}, {BUSH_MIDDLE_ID, &BUSH_MIDDLE_SRC},
    {BUSH_RIGHT_ID, &BUSH_RIGHT_SRC}, {CLOUD_LEFT_BOTTOM_ID, &CLOUD_LEFT_BOTTOM_SRC},
    {CLOUD_MIDDLE_BOTTOM_ID, &CLOUD_MIDDLE_BOTTOM_SRC}, {CLOUD_RIGHT_BOTTOM_ID, &CLOUD_RIGHT_BOTTOM_SRC},
    {CLOUD_LEFT_TOP_ID, &CLOUD_LEFT_TOP_SRC}, {CLOUD_MIDDLE_TOP_ID, &CLOUD_MIDDLE_TOP_SRC},
    {CLOUD_RIGHT_TOP_ID, &CLOUD_RIGHT_TOP_SRC}, {PIPE_LEFT_BOTTOM_ID, &PIPE_LEFT_BOTTOM_SRC},
    {PIPE_LEFT_TOP_ID, &PIPE_LEFT_TOP_SRC}, {PIPE_RIGHT_BOTTOM_ID, &PIPE_RIGHT_BOTTOM_SRC},
    {PIPE_RIGHT_TOP_ID, &PIPE_RIGHT_TOP_SRC}, {CASTLE_LEFT_ID, &CASTLE_LEFT_SRC},
    {CASTLE_RIGHT_ID, &CASTLE_RIGHT_SRC}, {CASTLE_BLACK_ID, &CASTLE_BLACK_SRC},
    {CASTLE_ENTRY_ID, &CASTLE_ENTRY_SRC}, {CASTLE_TOWER_ID, &CASTLE_TOWER_SRC},
    {CASTLE_TOWER_FILLED_ID, &CASTLE_TOWER_FILLED_SRC}, {VINE_TOP_ID, &VINE_TOP_SRC},
    {VINE_BOTTOM_ID, &VINE_BOTTOM_SRC}, {POLE_TOP_ID, &POLE_TOP_SRC},
    {POLE_BOTTOM_ID, &POLE_BOTTOM_SRC}, {FLAG_ID, &FLAG_SRC},
    {STEP_ID, &STEP_SRC}, {BRICK_ID, &BRICK_SRC}, {BRICK_TOP_ID, &BRICK_TOP_SRC},
    {SIDEWAY_PIPE_END_TOP_ID, &SIDEWAY_PIPE_END_TOP_SRC},
    {SIDEWAY_PIPE_END_BOTTOM_ID, &SIDEWAY_PIPE_END_BOTTOM_SRC},
    {SIDEWAY_PIPE_MIDDLE_TOP_ID, &SIDEWAY_PIPE_MIDDLE_TOP_SRC},
    {SIDEWAY_PIPE_MIDDLE_BOTTOM_ID, &SIDEWAY_PIPE_MIDDLE_BOTTOM_SRC},
    {SIDEWAY_PIPE_CONNECTOR_TOP_ID, &SIDEWAY_PIPE_CONNECTOR_TOP_SRC},
    {SIDEWAY_PIPE_CONNECTOR_BOTTOM_ID, &SIDEWAY_PIPE_CONNECTOR_BOTTOM_SRC},
    {TREE_PLATFORM_TOP_LEFT_ID, &TREE_PLATFORM_TOP_LEFT_SRC},
    {TREE_PLATFORM_TOP_MIDDLE_ID, &TREE_PLATFORM_TOP_MIDDLE_SRC},
    {TREE_PLATFORM_TOP_RIGHT_ID, &TREE_PLATFORM_TOP_RIGHT_SRC},
    {TREE_PLATFORM_BARK_ID, &TREE_PLATFORM_BARK_SRC},
    {WATER_TOP_ID, &WATER_TOP_SRC}, {WATER_FILL_ID, &WATER_FILL_SRC},
    {MUSHROOM_PLATFORM_TOP_LEFT_ID, &MUSHROOM_PLATFORM_TOP_LEFT_SRC},
    {MUSHROOM_PLATFORM_TOP_MIDDLE_ID, &MUSHROOM_PLATFORM_TOP_MIDDLE_SRC},
    {MUSHROOM_PLATFORM_TOP_RIGHT_ID, &MUSHROOM_PLATFORM_TOP_RIGHT_SRC},
    {MUSHROOM_PLATFORM_BARK_TOP_ID, &MUSHROOM_PLATFORM_BARK_TOP_SRC},
    {MUSHROOM_PLATFORM_BARK_BOTTOM_ID, &MUSHROOM_PLATFORM_BARK_BOTTOM_SRC},
    {TREE_BARK_ID, &TREE_BARK_SRC}, {TREE_LEAVES_SMALL_ID, &TREE_LEAVES_SMALL_SRC},
    {TREE_LEAVES_TOP_ID, &TREE_LEAVES_TOP_SRC},
    {TREE_LEAVES_BOTTOM_ID, &TREE_LEAVES_BOTTOM_SRC},
    {CANNON_TOWER_ID, &CANNON_TOWER_SRC},
    {CANNON_PEDESTAL_ID, &CANNON_PEDESTAL_SRC},
    {CANNON_ID, &CANNON_SRC}, {MARIO_ID, &MARIO_STANDING_SRC}
};

std::shared_ptr< SDLPP::RectangleRender >
createBlock( std::shared_ptr< SDLPP::Renderer > &renderer, int x, int y,
             std::shared_ptr< SDLPP::Texture > &texture, const SDL_Rect &src,
             uint64_t id, bool collision = false ) {
    auto block = std::make_shared<MarioBlock>(x, y, renderer, texture, src);
    block->setId( id );
    block->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    block->setStatic();
    if ( collision )
        block->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
    return block;
}

SDL_Rect getSourceRectByID( uint64_t id, BlockType type ) {
    if(block_mapping.find(id) == block_mapping.end())
        return {};
    SDL_Rect ret_src = *block_mapping.at(id);
    switch ( type ) {
    case OVERWORLD:
        ret_src.x += OVERWORLD_SHIFT.getX();
        ret_src.y += OVERWORLD_SHIFT.getY();
        break;
    case UNDERWORLD:
        ret_src.x += UNDERWORLD_SHIFT.getX();
        ret_src.y += UNDERWORLD_SHIFT.getY();
        break;
    case WATER:
        ret_src.x += WATER_SHIFT.getX();
        ret_src.y += WATER_SHIFT.getY();
        break;
    case BOWSER:
        ret_src.x += BOWSER_SHIFT.getX();
        ret_src.y += BOWSER_SHIFT.getY();
        break;
    }
    return ret_src;
}
std::shared_ptr<SDLPP::RectangleRender> createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr<SDLPP::Renderer> &renderer, int x, int y, std::shared_ptr<SDLPP::Texture> texture, bool collision ) {
    return createBlock( renderer, x, y, texture,
                        getSourceRectByID( block_id, type ), block_id,
                        collision );
}
std::shared_ptr<SDLPP::RectangleRender> createTerrainBlock( uint64_t block_id, BlockType type, std::shared_ptr<SDLPP::Renderer> &renderer, std::shared_ptr<SDLPP::Texture> texture, bool collision ) {
    return createTerrainBlock( block_id, type, renderer, 0, 0, texture, collision );
}

std::shared_ptr< SDLPP::RectangleRender >
createTerrainBlock( uint64_t block_id, BlockType type,
                    std::shared_ptr< SDLPP::Renderer > &renderer, int x,
                    int y, bool collision ) {
    return createTerrainBlock(block_id, type, renderer, x, y, g_terrain_texture, collision);
}

std::shared_ptr< SDLPP::RectangleRender >
createTerrainBlock( uint64_t block_id, BlockType type,
                    std::shared_ptr< SDLPP::Renderer > &renderer,
                    bool collision ) {
    return createTerrainBlock(block_id, type, renderer, g_terrain_texture, collision);
}

std::shared_ptr<SDLPP::RectangleRender> createMario( BlockType type, std::shared_ptr<SDLPP::Renderer> &renderer, int x, int y ) {
    //TODO add type additions
    auto mario = createBlock( renderer, x, y, g_mario_texture, MARIO_STANDING_SRC, MARIO_ID, true );
    dynamic_cast<MarioBlock&>(*mario).setTerrain(false);
    return mario;
}