#include "state_modify.hpp"

#include "game/game.hpp"
#include "map/map.hpp"
#include "defaults/ui.hpp"

StateModify::StateModify() {}
StateModify::~StateModify() {}

bool StateModify::Init(Game* game) {
    if (!game->renderer) {
        std::cerr << "Something went wrong in StateModify::Init\n";
    }

    //Tile::tileset_offset.x = Map::offset.x;
    //Tile::tileset_offset.y = Map::offset.y;
    cursor = game->cursor;
    cursor->state = CursorState::NORMAL;

    return true;
}

void StateModify::handle_Events(SDL_Event& event, Game* game) {
    if (game->input.cursor_over_tileset) {
        game->input.mouse_game_offset = {static_cast<int>(Tile::tileset_offset.x), 
                                         static_cast<int>(Tile::tileset_offset.y) };
    }


    switch (event.type) {
        case SDL_EVENT_KEY_DOWN:
            switch (event.key.scancode) {
                case SDL_SCANCODE_H:
                    Tile::draw_tile_set = !Tile::draw_tile_set;
                    break;
                case SDL_SCANCODE_O:
                    Tile::tile_selected   = false;
                    Tile::object_selected = false;
                    Tile::draw_tile_set   = true;

                    ModifyState_s state;
                    if (Tile::active_tileset_type == TILE_BACKGROUND) {
                        state = MODIFY_FLOOR_TYPE;
                    } else {
                        if (game->input.pressed_ctrl)
                            state = MODIFY_OBJECTS_PROPS;
                        else if (game->input.pressed_shift)
                            state = MODIFY_OBJECTS_PROPS_RESOURCE;
                        else
                            state = MODIFY_OBJECTS;
                    }

                    Default::modify_state = (Default::modify_state != state)
                        ? state
                        : MODIFY_TILES;
                    break;
                case SDL_SCANCODE_M:
                    // if (Default::game_state != GAME_MODIFY || !Tile::draw_tile_set) break;
                    if (!Tile::draw_tile_set) {
                        Tile::draw_tile_set   = true;
                        break;
                    }

                    Tile::tile_selected   = false;
                    Tile::object_selected = false;
                    Tile::draw_tile_set   = true;
                    if (game->input.pressed_ctrl) {
                        Default::modify_state = MODIFY_TILES;
                            Tile::active_tileset_type =
                            static_cast<TileType>(
                                (Tile::active_tileset_type + 1) == TILE_TYPE_LAST
                                ? TILE_TYPE_FIRST+1
                                : Tile::active_tileset_type+1
                            );
                        Tile::active_tileset_id = 0;
                    } else if (game->input.pressed_shift)
                        Tile::active_tileset_id =
                            Tile::active_tileset_id == 0
                            ? Tile::tilesets[Tile::active_tileset_type].size() - 1
                            : Tile::active_tileset_id -1;
                    else {
                        Tile::active_tileset_id =
                            (Tile::active_tileset_id + 1) % Tile::tilesets[Tile::active_tileset_type].size();
                    }

                    Tile::active_tileset = &Tile::tilesets[Tile::active_tileset_type][Tile::active_tileset_id];
                    //Tile::fix_TilesetObjectInfo();
                    break;
                case SDL_SCANCODE_RIGHTBRACKET:
                    if (game->input.pressed_ctrl) {
                        Tile::selection_tile_dimension.x++;
                        Tile::selection_tile_dimension.y++;
                    } else if (game->input.pressed_shift)
                        Tile::selection_tile_dimension.y++;
                    else
                        Tile::selection_tile_dimension.x++;
                    break;
                case SDL_SCANCODE_SLASH: // thats - MINUS
                    if (game->input.pressed_ctrl) {
                        Tile::selection_tile_dimension.x = Tile::selection_tile_dimension.x > 0
                            ? Tile::selection_tile_dimension.x -1 : 0;
                        Tile::selection_tile_dimension.y = Tile::selection_tile_dimension.y > 1
                            ? Tile::selection_tile_dimension.y -1 : 1;
                    } else if (game->input.pressed_shift)
                        Tile::selection_tile_dimension.y = Tile::selection_tile_dimension.y > 1
                            ? Tile::selection_tile_dimension.y -1 : 1;
                    else
                        Tile::selection_tile_dimension.x = Tile::selection_tile_dimension.x > 1
                            ? Tile::selection_tile_dimension.x -1 : 1;
                    break;
                case SDL_SCANCODE_0:
                    if (game->input.pressed_ctrl)
                        Tile::selection_tile_dimension = {1,1};
                    break;
                case SDL_SCANCODE_S:
                    if (game->input.pressed_ctrl) {
                        Map::save_MapTiles(Map::tile_map, Map::save_path);
                        Map::save_TileCollision( Map::save_collission_path);
                        Tile::save_Collissions();
                        Tile::save_Objects();
                    } else {
                        Default::game_scale = (Default::game_scale == 1) ? 2 : 1;
                    }
                    break;
                case SDL_SCANCODE_R:
                    if (game->input.pressed_ctrl) {
                        Map::Reset();
                    }
                    break;
                case SDL_SCANCODE_K:
                    if (game->input.pressed_shift) {
                        Map::init_Collider();
                    } else if (game->input.pressed_ctrl
                               && Default::modify_state == MODIFY_COLLISSION) {
                        Map::set_CollissionFromTileset();
                    } else
                    Default::modify_state = (Default::modify_state != MODIFY_COLLISSION)
                        ? MODIFY_COLLISSION
                        : MODIFY_TILES;
                    break;
                default: break;
            }
        default: break;
    }
}

void StateModify::StateModify::Update(Game* game) {
    // SET Map offset
    if ((!game->input.cursor_over_tileset && !Tile::setting_tileset_offset) || Map::setting_offset)
        Map::set_Offset(game->input);

    bool hovering_set = Tile::hovering_set;

    if (Default::modify_state == MODIFY_COLLISSION) {
        if (game->input.click_left_released) {
            if (hovering_set)
                Tile::set_Collission(game->input);
            else 
                Map::set_Collission(game->input);
        }
    } else if (Default::modify_state == MODIFY_OBJECTS) {
        if (game->input.click_left_released) {
            if (hovering_set)
                Tile::set_Object(game->input);
        }
    } else if (Default::modify_state == MODIFY_OBJECTS_PROPS) {
        Tile::set_ObjectProps(game->input);
    } else if (Default::modify_state == MODIFY_OBJECTS_PROPS_RESOURCE) {
        ResourceData::set_ObjectPropsResource(game->input);
    } else if (Default::modify_state == MODIFY_FLOOR_TYPE) {
        Tile::set_FloorType(game->input);
    } else if (game->input.click_left_released && game->input.pressed_c) {
        Tile::clear_Objects(game->input);
    } else if ((game->input.click_left || game->input.click_left_released)&& !game->input.pressed_ctrl) {
        Tile::transfer_ToMap(game->input);
    }
    if (!Map::setting_offset && (hovering_set || Tile::setting_tileset_offset))
        Tile::set_TilesetOffset(game->input);
}

void StateModify::StateModify::Render(Game* game) {
    if (Tile::draw_tile_set) {
        Tile::draw_Tileset(game->renderer, game->input);
    }

    if (Tile::object_selected)
        Tile::draw_SelectedObject(game->renderer, game->input);

    Ui::draw_TopBarTileInfo(game->renderer, game->win_size);

    Map::draw_SelectionBorder(game->renderer, game->input);

}