#include "../sdlpp/sdlpp.hpp"
#include "sprites.hpp"
#ifdef _WIN32
#include "../sdlpp/SDL2/SDL2_framerate.h"
#include <ctime>
#include <string>
#include <windows.h>
#else
#include <SDL2/SDL2_framerate.h>
#endif // UNIX

#include <array>
#include <thread>
#include <mutex>
#include "global_vars.hpp"
#include "objectids.hpp"
#include "blocks.hpp"
#include "maploader.hpp"
#include "../sdlpp/sdlpp_mouse.hpp"
#include "edit_box.hpp"
#include "editor_visitor.hpp"
#include "tool_box.hpp"

#define MAP_WIDTH 50
#define MAP_HEIGHT 16

struct MouseInfo {
    enum Index {
        CUR_FLAGS = 0,
        PREV_FLAGS = 1,
        EDIT_BOX = 2,
        TOOL_BOX = 3,
    };
};

struct MapInfo {
    enum Value {
        CUR_PAGE = 0,
        MAX_PAGE = 1,
    };
};

struct ToolInfo {
    enum Value {
        INDEX = 0,
        CUR_PAGE = 1,
        MAX_PAGE = 2,
    };
};

std::shared_ptr< SDLPP::Renderer > g_renderer = nullptr;
bool g_quit = false;
bool g_update_size = false;
std::vector< mapColumnType > g_objects = {};
std::vector< std::shared_ptr< SDLPP::RenderObject > > g_tools{};
std::shared_ptr< SDLPP::RenderObject > g_current_tool = nullptr;

std::mutex g_destruction_mutex;

// current mouse flags, previous mouse flags, selected edit box, selected tool
// box
std::tuple< uint64_t, uint64_t, SDLPP::Vec2D< int >, SDLPP::Vec2D< int > >
    g_mouse_info;
// current page, max page
std::tuple< int, int > g_map_info;
// tool index (in possibleBlocks), current pange, max page
std::tuple<uint64_t, int, int> g_tool_info;

std::shared_ptr< SDLPP::Texture > g_placeholder_texture = nullptr;
std::shared_ptr< SDLPP::Texture > g_placeholder_mario = nullptr;

std::shared_ptr< SDLPP::RenderObject > g_mario = nullptr;
SDLPP::Vec2D< int > g_mario_pos = { 0, 0 };

enum LandType::Value g_current_world_type = LandType::OVERWORLD;

void updateTool() {
    auto tool_role = getBlockRole( possibleBlocks[std::get<ToolInfo::INDEX>(g_tool_info)] );
    std::shared_ptr< SDLPP::Texture > target_texture = nullptr;
    switch ( tool_role ) {
    case BlockRole::TERRAIN:
        target_texture = g_placeholder_texture;
        break;
    case BlockRole::MARIO:
        target_texture = g_placeholder_mario;
        break;
    case BlockRole::MODIFIER:
        break;
    case BlockRole::CHARACTER:
        break;
    }
    g_current_tool->setTexture(
        target_texture, getSourceRectByID( possibleBlocks[std::get<ToolInfo::INDEX>(g_tool_info)],
                                           g_current_world_type ) );
    g_current_tool->setId( possibleBlocks[std::get<ToolInfo::INDEX>(g_tool_info)] );
    g_current_tool->getCollisions()[0]->setId(
        possibleBlocks[std::get<ToolInfo::INDEX>(g_tool_info)] );
}

void removeMario() {
    if ( !g_mario )
        return;
    auto prev = g_objects[g_mario_pos.getX()][g_mario_pos.getY()];
    // remove character/modifiers
    g_objects[g_mario_pos.getX()][g_mario_pos.getY()] = {
        std::get< 0 >( prev ), std::get< 1 >( prev ), 0, 0, 0, 0
    };
    g_mario->destroy();
}

void updateToolSelection( int prev_index ) {
    size_t prev = prev_index * 8;
    size_t cur = std::get<ToolInfo::CUR_PAGE>(g_tool_info) * 8;
    for ( size_t i = prev;
          i < ( g_tools.size() < prev + 8 ? g_tools.size() : prev + 8 ); i++ ) {
        g_tools[i]->setHidden( true );
    }
    for ( size_t i = cur;
          i < ( g_tools.size() < cur + 8 ? g_tools.size() : cur + 8 ); i++ ) {
        g_tools[i]->setHidden( false );
    }
}

void moveToolsLeft() {
    std::get<ToolInfo::CUR_PAGE>(g_tool_info)--;
    updateToolSelection( std::get<ToolInfo::CUR_PAGE>(g_tool_info) + 1 );
}

void moveToolsRight() {
    std::get<ToolInfo::CUR_PAGE>(g_tool_info)++;
    updateToolSelection( std::get<ToolInfo::CUR_PAGE>(g_tool_info) - 1 );
}

// TODO add red outline to currently selected tool
// add WSAD navigation for the red highlight
void selectPrevTool() {
    if ( std::get<ToolInfo::INDEX>(g_tool_info) == 0 )
        return;
    if ( std::get<ToolInfo::INDEX>(g_tool_info) % 8 == 0 ) {
        moveToolsLeft();
    }
    std::get<ToolInfo::INDEX>(g_tool_info)--;
    updateTool();
}

void selectNextTool() {
    if ( std::get<ToolInfo::INDEX>(g_tool_info) == g_tools.size() - 1 )
        return;
    if ( std::get<ToolInfo::INDEX>(g_tool_info) % 8 == 7 ) {
        moveToolsRight();
    }
    std::get<ToolInfo::INDEX>(g_tool_info)++;
    updateTool();
}

void handleKeyUp( SDL_Keycode key, SDLPP::Scene &scene ) {
    switch ( key ) {
    case SDLK_ESCAPE:
        g_quit = true;
        break;
    case SDLK_a:
        selectPrevTool();
        break;
    case SDLK_d:
        selectNextTool();
        break;
    case SDLK_r:
        scene.getRenderer().setRenderColiders(
            !scene.getRenderer().getRenderColiders() );
    default:
        break;
    }
}

void getMousePositionFlags( SDLPP::Scene &scene ) {
    auto mouse = scene.getObjects( { EDITOR_MOUSE_ID } )[0];
    // move mouse colider to mouse position
    mouse->setPos( SDLPP::Mouse::getMousePositionDouble(
        scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER ) );

    MouseVisitor visitor;
    scene.visitCollisions( *mouse, visitor );
    std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ) = visitor.getFlags();
    std::get< MouseInfo::EDIT_BOX >( g_mouse_info ) =
        visitor.getEditBoxIndexes();
    std::get< MouseInfo::TOOL_BOX >( g_mouse_info ) =
        visitor.getToolBoxIndexes();
    // if we found an edit box, move tool icon to that box
    if ( visitor.foundEditBox() ) {
        const auto &box = std::get< MouseInfo::EDIT_BOX >( g_mouse_info );
        g_current_tool->setPos( BLOCK_SIZE + box.getX() * BLOCK_SIZE,
                                (MAP_WIDTH - MAP_HEIGHT + 2) * BLOCK_SIZE + box.getY() * BLOCK_SIZE );
    }
}

void mouseUpAction( uint64_t flags, SDLPP::Scene &scene ) {
    if ( MouseVisitor::moveMapLeft( flags ) && std::get<MapInfo::CUR_PAGE>(g_map_info) != 0 ) {
        std::get<MapInfo::CUR_PAGE>(g_map_info)--;
        scene.moveEverything( BLOCK_SIZE, 0 );
    }
    if ( MouseVisitor::moveMapRight( flags ) ) {
        if ( std::get<MapInfo::CUR_PAGE>(g_map_info) == std::get<MapInfo::MAX_PAGE>(g_map_info) ) {
            // add column
            g_objects.resize( g_objects.size() + 1 );
            std::get<MapInfo::MAX_PAGE>(g_map_info)++;
        }
        std::get<MapInfo::CUR_PAGE>(g_map_info) += 1;
        scene.moveEverything( -BLOCK_SIZE, 0 );
    }
    if ( MouseVisitor::moveToolsLeft( flags ) && std::get<ToolInfo::CUR_PAGE>(g_tool_info) != 0 ) {
        std::get<ToolInfo::CUR_PAGE>(g_tool_info) -= 1;
        updateToolSelection( std::get<ToolInfo::CUR_PAGE>(g_tool_info) + 1 );
    }
    if ( MouseVisitor::moveToolsRight( flags ) &&
         std::get<ToolInfo::CUR_PAGE>(g_tool_info) != std::get<ToolInfo::MAX_PAGE>(g_tool_info) ) {
        std::get<ToolInfo::CUR_PAGE>(g_tool_info) += 1;
        updateToolSelection( std::get<ToolInfo::CUR_PAGE>(g_tool_info) - 1 );
    }
}

SDLPP::Vec2D< int > getSelectedObjectPosition() {
    return { std::get<MapInfo::CUR_PAGE>(g_map_info) +
                 std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX(),
             std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getY() };
}

mapObjectType &getSelectedObject() {
    auto pos = getSelectedObjectPosition();
    return g_objects[pos.getX()][pos.getY()];
}

void placeTool( SDLPP::Scene &scene ) {
    std::lock_guard< std::mutex > lock( g_destruction_mutex );

    ToolVisitor visitor;
    auto tool_type = getBlockRole( g_current_tool->getId() );
    switch ( tool_type ) {
    case BlockRole::TERRAIN:
        visitor.setVisitorType( VisitorType::Terrain );
        break;
    default:
        visitor.setVisitorType( VisitorType::Modifier );
        break;
    }

    scene.visitCollisions( *g_current_tool, visitor );
    if ( visitor.removeBlock() && !visitor.addBlock() ) {
        auto &obj = getSelectedObject();
        switch ( visitor.getVisitorType() ) {
        case VisitorType::Terrain:
            std::get< MapObject::TERRAIN_TYPE >( obj ) = LandType::OVERWORLD;
            std::get< MapObject::TERRAIN_ID >( obj ) = 0;
            break;
        case VisitorType::Modifier:
            std::get< MapObject::CHARACTER_TYPE >( obj ) = 0;
            std::get< MapObject::CHARACTER_ID >( obj ) = 0;
            std::get< MapObject::MODIFIER_TYPE >( obj ) = 0;
            std::get< MapObject::MODIFIER_DATA >( obj ) = 0;
            break;
        default:
            break;
        }
    } else if ( visitor.addBlock() ) {
        auto &obj = getSelectedObject();
        int z_index = 1;
        std::shared_ptr< SDLPP::RenderObject > new_obj = nullptr;
        switch ( visitor.getVisitorType() ) {
        case VisitorType::Terrain:
            std::get< MapObject::TERRAIN_TYPE >( obj ) = LandType::OVERWORLD;
            std::get< MapObject::TERRAIN_ID >( obj ) = g_current_tool->getId();
            // TODO why 1 +?
            new_obj = createTerrainBlock(
                g_current_tool->getId(), LandType::OVERWORLD, g_renderer,
                1 + std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX(),
                std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getY(), true );
            new_obj->getCollisions()[0]->setId( EDITOR_TERRAIN_ID );
            break;
        case VisitorType::Modifier:
            // TODO check if modifier or character
            std::get< MapObject::CHARACTER_TYPE >( obj ) = LandType::OVERWORLD;
            // TODO character ID
            std::get< MapObject::CHARACTER_ID >( obj ) = MARIO_ID;
            std::get< MapObject::MODIFIER_TYPE >( obj ) = 0;
            std::get< MapObject::MODIFIER_DATA >( obj ) = 0;
            new_obj = createMario(
                LandType::OVERWORLD, g_renderer,
                1 + std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX(),
                std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getY() );
            // remove mario if exists
            removeMario();
            g_mario = new_obj;
            g_mario_pos = getSelectedObjectPosition();
            new_obj->getCollisions()[0]->setId( EDITOR_CHARACTER_ID );
            z_index = scene.getObjects().size() - 1;
            break;
        default:
            break;
        }
        scene.addObject( new_obj );
        scene.setZIndex( new_obj, z_index );
    }
}

void pollEvents( SDLPP::Scene &scene ) {
    SDL_Event event;
    while ( SDLPP::getSDLEvent( event ) ) {
        switch ( event.type ) {
        case SDL_QUIT:
            g_quit = true;
            break;
        case SDL_KEYUP:
            handleKeyUp( event.key.keysym.sym, scene );
            break;
        case SDL_WINDOWEVENT:
            if ( event.window.event == SDL_WINDOWEVENT_RESIZED ) {
                g_update_size = true;
            }
            break;
        case SDL_MOUSEMOTION:
            getMousePositionFlags( scene );
            break;
        case SDL_MOUSEBUTTONUP:
            if ( std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ) ==
                 std::get< MouseInfo::PREV_FLAGS >( g_mouse_info ) ) {
                mouseUpAction( std::get< MouseInfo::CUR_FLAGS >( g_mouse_info ),
                               scene );
            }
            if ( std::get< MouseInfo::EDIT_BOX >( g_mouse_info ).getX() !=
                 -1 ) {
                placeTool( scene );
            }
            if ( std::get< MouseInfo::TOOL_BOX >( g_mouse_info ).getX() !=
                 -1 ) {
                auto &tool_box =
                    std::get< MouseInfo::TOOL_BOX >( g_mouse_info );
                size_t index = tool_box.getY() * 4 + tool_box.getX();
                if ( index < g_tools.size() ) {
                    std::get<ToolInfo::INDEX>(g_tool_info) = std::get<ToolInfo::CUR_PAGE>(g_tool_info) * 8 + index;
                    updateTool();
                }
            }
            break;
        case SDL_MOUSEBUTTONDOWN:
            // store current mouse flags in previous mouse flags
            std::get< MouseInfo::PREV_FLAGS >( g_mouse_info ) =
                std::get< MouseInfo::CUR_FLAGS >( g_mouse_info );
            break;
        default:
            break;
        }
    }
}

void doInput( std::shared_ptr< SDLPP::Scene > scene ) {
    FPSmanager gFPS;
    SDL_initFramerate( &gFPS );
    SDL_setFramerate( &gFPS, 200 );
    while ( true ) {
        SDL_framerateDelay( &gFPS );
        pollEvents( *scene );
        scene->updateScene();
    }
}

#ifdef _WIN32
int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     PWSTR szCmdLine, int nCmdShow ) {
#else
int main() {
#endif
    SDLPP::init();
    SDLPP::Window w( "Mario editor!" );
    w.setResizable( true );
    BLOCK_SIZE = 1.0 / (MAP_WIDTH + 2);

    g_renderer = std::make_shared< SDLPP::Renderer >( w );
    g_renderer->setBlendMode( SDL_BLENDMODE_BLEND );

    // prepare global vars
    g_terrain_texture = std::make_shared< SDLPP::Texture >(
        g_renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY );
    g_mario_texture = std::make_shared< SDLPP::Texture >(
        g_renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY );

    auto scene = std::make_shared< SDLPP::Scene >( g_renderer );
    auto bg = std::make_shared< SDLPP::RectangleRender >(
        0, 0, 10, 10, g_renderer, MARIO_OVERWORLD_COLORKEY, true );
    bg->setPermanent();
    bg->setId( 1 );
    scene->addObject( bg );

    loadMap( scene, "test_binary.bin", g_renderer, g_objects );

    // grid
    for ( int i = 1; i < (MAP_WIDTH + 2); i++ ) {
        auto line_vertical = std::make_shared< SDLPP::LineRenderer >(
            i * BLOCK_SIZE, 1 - MAP_HEIGHT * BLOCK_SIZE, i * BLOCK_SIZE, 1.0,
            g_renderer, "#282828" );
        line_vertical->setPermanent();
        line_vertical->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
        scene->addObject( line_vertical );
        if ( i > (MAP_WIDTH - MAP_HEIGHT) ) {
            auto line_horizontal = std::make_shared< SDLPP::LineRenderer >(
                BLOCK_SIZE, ( i + 1 ) * BLOCK_SIZE, (MAP_WIDTH+1) * BLOCK_SIZE,
                ( i + 1 ) * BLOCK_SIZE, g_renderer, "#282828" );
            line_horizontal->setPermanent();
            line_horizontal->setAlignment( SDLPP::OBJ_CENTER,
                                           SDLPP::OBJ_CENTER );
            scene->addObject( line_horizontal );
        }
    }
    // white rectangles
    auto rectangle1 = std::make_shared< SDLPP::RectangleRender >(
        0, (MAP_WIDTH + 2 - MAP_HEIGHT) * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE, g_renderer, "#FFFFFF88",
        true );
    rectangle1->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    rectangle1->setId( EDITOR_LEFT_MAP_ID );
    rectangle1->setPermanent();
    rectangle1->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
    scene->addObject( rectangle1 );
    // white rectangles
    auto rectangle2 = std::make_shared< SDLPP::RectangleRender >(
        (MAP_WIDTH+1) * BLOCK_SIZE, (MAP_WIDTH + 2 - MAP_HEIGHT) * BLOCK_SIZE, BLOCK_SIZE, MAP_HEIGHT * BLOCK_SIZE,
        g_renderer, "#FFFFFF88", true );
    rectangle2->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    rectangle2->setId( EDITOR_RIGHT_MAP_ID );
    rectangle2->setPermanent();
    rectangle2->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
    scene->addObject( rectangle2 );

    auto font = std::make_shared< SDLPP::Font >( "testfont.ttf", 36 );
    auto font_config = std::make_shared< SDLPP::FontConfiguration >(
        font, "#000000", "#282828", 0.05 );
    auto left = std::make_shared< SDLPP::TextRenderer >(
        0, (MAP_WIDTH - MAP_HEIGHT/2.0 + 1.5) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer, "<",
        font_config );
    left->setId( 0 );
    left->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    left->setPermanent();
    scene->addObject( left );
    auto right = std::make_shared< SDLPP::TextRenderer >(
        (MAP_WIDTH+1) * BLOCK_SIZE, (MAP_WIDTH - MAP_HEIGHT/2.0 + 1.5) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
        ">", font_config );
    right->setId( 0 );
    right->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    right->setPermanent();
    scene->addObject( right );

    for ( int i = 0; i < MAP_WIDTH; i++ ) {
        for ( int j = 0; j < MAP_HEIGHT; j++ ) {
            scene->addObject( std::make_shared< EditBox >( i, j, MAP_WIDTH, MAP_HEIGHT, g_renderer ) );
        }
    }

    auto mouse = std::make_shared< SDLPP::RectangleRender >( 0.01, 0.01, 0, 0,
                                                             g_renderer );
    mouse->setMinWidth( 1 );
    mouse->setMinHeight( 1 );
    mouse->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    mouse->setId( EDITOR_MOUSE_ID );
    mouse->setColiderColor( "#00FF00" );
    mouse->addCollision( SDLPP::RectColider( { 0, 0 }, { 1, 1 } ) );
    scene->addObject( mouse );
    std::get<MapInfo::MAX_PAGE>(g_map_info) = g_objects.size() - MAP_WIDTH;

    // tools
    std::get<ToolInfo::MAX_PAGE>(g_tool_info) = ( possibleBlocks.size() - 1 ) / 8;
    for ( int i = 0; i < 4; i++ ) {
        auto tool_box1 = std::make_shared< ToolBox >( i, 0, MAP_WIDTH, MAP_HEIGHT, g_renderer );
        auto tool_box2 = std::make_shared< ToolBox >( i, 1, MAP_WIDTH, MAP_HEIGHT, g_renderer );
        scene->addObject( tool_box1 );
        scene->addObject( tool_box2 );
        //        std::cout << "TOOL BOX POS: " << tool_box1->getPos().getX() <<
        //        ", " << tool_box1->getPos().getY() << std::endl; std::cout <<
        //        "TOOL BOX POS: " << tool_box2->getPos().getX() << ", " <<
        //        tool_box2->getPos().getY() << std::endl;
    }
    int tool_index = 0;
    for ( auto &block : possibleBlocks ) {
        if ( block == MARIO_ID ) {
            g_tools.push_back(
                createMario( LandType::OVERWORLD, g_renderer, 0, 0 ) );
        } else {
            g_tools.push_back( createTerrainBlock( block, LandType::OVERWORLD,
                                                   g_renderer, false ) );
        }
        g_tools.back()->setHidden( true );
        g_tools.back()->setPermanent();
        auto x = tool_index % 4;
        auto y = tool_index / 4;
        // TODO add 14 and 1 as constants somewhere
        // TODO investigate when not permanent requires `-1` on x position
        g_tools.back()->setPos( (MAP_WIDTH - 4) * BLOCK_SIZE + x * BLOCK_SIZE,
                                BLOCK_SIZE + y * BLOCK_SIZE );
        //        std::cout << "TOOL POS: " << tools.back()->getPos().getX() <<
        //        ", " << tools.back()->getPos().getY() << std::endl;
        scene->addObject( g_tools.back() );
        tool_index = ( tool_index + 1 ) % 8;
    }
    for ( int i = 0; i < 5; i++ ) {
        auto line = std::make_shared< SDLPP::LineRenderer >(
            (MAP_WIDTH - 4) * BLOCK_SIZE + i * BLOCK_SIZE, BLOCK_SIZE,
            (MAP_WIDTH - 4) * BLOCK_SIZE + i * BLOCK_SIZE, 3 * BLOCK_SIZE, g_renderer,
            "#282828" );
        line->setPermanent();
        line->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
        scene->addObject( line );
    }
    for ( int i = 0; i < 3; i++ ) {
        auto line = std::make_shared< SDLPP::LineRenderer >(
            (MAP_WIDTH - 4) * BLOCK_SIZE, BLOCK_SIZE + i * BLOCK_SIZE,
            (MAP_WIDTH - 4) * BLOCK_SIZE + 4 * BLOCK_SIZE, BLOCK_SIZE + i * BLOCK_SIZE,
            g_renderer, "#282828" );
        line->setPermanent();
        line->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
        scene->addObject( line );
    }

    auto tool_rect1 = std::make_shared< SDLPP::RectangleRender >(
        (MAP_WIDTH-5) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_renderer,
        "#FFFFFF88", true );
    tool_rect1->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    tool_rect1->setId( EDITOR_LEFT_TOOL_ID );
    tool_rect1->setPermanent();
    tool_rect1->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
    scene->addObject( tool_rect1 );
    // white rectangles
    auto tool_rect2 = std::make_shared< SDLPP::RectangleRender >(
        MAP_WIDTH * BLOCK_SIZE, 1 * BLOCK_SIZE, BLOCK_SIZE, 2 * BLOCK_SIZE, g_renderer,
        "#FFFFFF88", true );
    tool_rect2->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    tool_rect2->setId( EDITOR_RIGHT_TOOL_ID );
    tool_rect2->setPermanent();
    tool_rect2->addCollision( SDLPP::RectColider( 0, 0, 1, 1 ) );
    scene->addObject( tool_rect2 );
    auto left_tool = std::make_shared< SDLPP::TextRenderer >(
        (MAP_WIDTH-5) * BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
        "<", font_config );
    left_tool->setId( 0 );
    left_tool->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    left_tool->setPermanent();
    scene->addObject( left_tool );
    auto right_tool = std::make_shared< SDLPP::TextRenderer >(
        MAP_WIDTH * BLOCK_SIZE, 1.5 * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE, g_renderer,
        ">", font_config );
    right_tool->setId( 0 );
    right_tool->setAlignment( SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER );
    right_tool->setPermanent();
    scene->addObject( right_tool );

    g_placeholder_texture = std::make_shared< SDLPP::Texture >(
        g_renderer, "sprites/terrain.png", MARIO_OVERWORLD_COLORKEY );
    g_placeholder_texture->setAlpha( 100 );
    g_placeholder_mario = std::make_shared< SDLPP::Texture >(
        g_renderer, "sprites/mario.png", MARIO_OVERWORLD_COLORKEY );
    g_placeholder_mario->setAlpha( 100 );
    g_current_tool = createTerrainBlock( possibleBlocks[std::get<ToolInfo::INDEX>(g_tool_info)],
                                         LandType::OVERWORLD, g_renderer,
                                         g_placeholder_texture, false );
    g_current_tool->addCollision( SDLPP::RectColider( 0.1, 0.1, 0.8, 0.8 ) );
    dynamic_cast< MarioBlock & >( *g_current_tool ).setTool();
    scene->addObject( g_current_tool );
    scene->moveZTop( g_current_tool );

    scene->moveEverything( BLOCK_SIZE, 0 );
    FPSmanager gFPS;
    SDL_initFramerate( &gFPS );
    SDL_setFramerate( &gFPS, 60 );

    updateToolSelection( 0 );

    auto base = SDL_GetTicks();
    int frames = 0;
    std::thread inputThread( doInput, scene );
    inputThread.detach();
    while ( !g_quit ) {
        SDL_PumpEvents();
        SDL_framerateDelay( &gFPS );
        std::lock_guard< std::mutex > lock( g_destruction_mutex );
        scene->renderScene();
        g_renderer->presentRenderer();
        frames++;
        if ( SDL_GetTicks() - base >= 1000 ) {
            std::cout << "FPS: " << frames << std::endl;
            frames = 0;
            base = SDL_GetTicks();
        }
        if ( std::get<MapInfo::CUR_PAGE>(g_map_info) == 0 ) {
            left->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 );
        } else {
            left->setTextColor( font, "#000000", "#282828", 0.05 );
        }
        if ( std::get<MapInfo::CUR_PAGE>(g_map_info) == std::get<MapInfo::MAX_PAGE>(g_map_info) ) {
            right->setTextColor( font, "#00FF00", "#000000", 0.1 );
            right->changeText( "+" );
        } else {
            right->setTextColor( font, "#000000", "#282828", 0.05 );
            right->changeText( ">" );
        }
        if ( std::get<ToolInfo::CUR_PAGE>(g_tool_info) == 0 ) {
            left_tool->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 );
        } else {
            left_tool->setTextColor( font, "#000000", "#282828", 0.05 );
        }
        if ( std::get<ToolInfo::CUR_PAGE>(g_tool_info) == std::get<ToolInfo::MAX_PAGE>(g_tool_info) ) {
            right_tool->setTextColor( font, "#CCCCCC", "#CCCCCC", 0.05 );
        } else {
            right_tool->setTextColor( font, "#000000", "#282828", 0.05 );
        }
        if ( g_update_size ) {
            scene->updateSizeAndPosition();
        }
    }
    saveMap( "test_binary2.bin", g_objects );

    return 0;
}