#include "editor_scenes.hpp"
#include "../../sdlpp/sdlpp.hpp"
#include "../../sdlpp/sdlpp_mouse.hpp"
#include "../global_vars.hpp"
#include "../objectids.hpp"
#include "../editor_visitor.hpp"
#include <functional>
#include "../sprites.hpp"

bool __update_scenes_main_menu = false;
bool __quit_scenes_main_menu = false;
bool __restart_scenes_main_menu = false;
bool __started_main_menu = false;
bool __include_resume = false;
uint64_t __cur_button_index_main_menu = -1;
uint64_t __cur_button_index_main_menu_down = -1;
std::vector<std::shared_ptr<Button>> __buttons_main_menu{};
std::shared_ptr<SDLPP::RectangleRender> __mouse_main_menu{};

extern void loadLevel(const std::string &level);
extern void loadLastLevel();

void quitMainMenu() {
    g_quit = true;
}

void resumeMainMenu() {
    __quit_scenes_main_menu = true;
}

void restartMainMenu() {
    __quit_scenes_main_menu = true;
    __restart_scenes_main_menu = true;
}

void quitMainMenuCallback(void * /*UNUSED*/, Button * /*UNUSED*/) {
    quitMainMenu();
}

void resumeMainMenuCallback(void * /*UNUSED*/, Button * /*UNUSED*/) {
    resumeMainMenu();
}

void restartMainMenuCallback(void * /*UNUSED*/, Button * /*UNUSED*/) {
    restartMainMenu();
}

void resetGlobals() {
    __update_scenes_main_menu = false;
    __quit_scenes_main_menu = false;
    __restart_scenes_main_menu = false;
    __started_main_menu = false;
    __cur_button_index_main_menu_down = -1;
    __mouse_main_menu.reset();
    __buttons_main_menu.clear();
}

void showLoadMenu(void * /*UNUSED*/, Button * /*UNUSED*/) {
    auto loadMenu = createLoadScene(__buttons_main_menu.back()->getRenderer(),
                                    "levels", loadLevel, false, false);
    std::lock_guard<std::mutex> lock(render_mutex);
    game_scenes.pop_back();
    resetGlobals();
    game_scenes.push_back(loadMenu);
}

void __updateSelectedButton_MainMenu(uint64_t new_index) {
    if (new_index != (uint64_t)-1) {
        __buttons_main_menu[new_index]->setHighlight();

        if (__cur_button_index_main_menu != (uint64_t)-1 &&
            new_index != __cur_button_index_main_menu) {
            __buttons_main_menu[__cur_button_index_main_menu]->unsetHighlight();
        }
        __cur_button_index_main_menu = new_index;
    }
}

void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) {
    switch (key) {
    case SDLK_ESCAPE:
        if (__include_resume) {
            resumeMainMenu();
        } else {
            quitMainMenu();
        }
        break;
    case SDLK_DOWN:
    case SDLK_s:
        if (__cur_button_index_main_menu == __buttons_main_menu.size() - 1) {
            __updateSelectedButton_MainMenu(0);
        } else {
            __updateSelectedButton_MainMenu(__cur_button_index_main_menu + 1);
        }
        break;
    case SDLK_UP:
    case SDLK_w:
        if (__cur_button_index_main_menu == 0) {
            __updateSelectedButton_MainMenu(__buttons_main_menu.size() - 1);
        } else {
            __updateSelectedButton_MainMenu(__cur_button_index_main_menu - 1);
        }
        break;
    case SDLK_RETURN:
        if (__cur_button_index_main_menu >= 0 &&
            __cur_button_index_main_menu < __buttons_main_menu.size()) {
            __buttons_main_menu[__cur_button_index_main_menu]
                ->performFunction();
        }
        break;
    default:
        break;
    }
}

std::shared_ptr<SDLPP::Scene>
createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer,
                    bool include_restart, bool include_resume,
                    bool transparent_bg) {
    auto scene = std::make_shared<SDLPP::Scene>(renderer);
    auto bg = std::make_shared<SDLPP::RectangleRender>(
        0, 0, 10, 10, renderer,
        transparent_bg ? "#00000088" : MARIO_OVERWORLD_COLORKEY, true);
    bg->setPermanent();
    bg->setId(1);
    scene->addObject(bg);
    __mouse_main_menu =
        std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer);
    __mouse_main_menu->setMinWidth(1);
    __mouse_main_menu->setMinHeight(1);
    __mouse_main_menu->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
    __mouse_main_menu->setId(EDITOR_MOUSE_ID);
    __mouse_main_menu->setColiderColor("#00FF00");
    __mouse_main_menu->addCollision(SDLPP::RectColider({ 0, 0 }, { 1, 1 }));
    scene->addObject(__mouse_main_menu);

    ButtonConfig default_button_theme{};
    default_button_theme.bg_color = "#FFFFFF88";
    default_button_theme.bg_color_highlight = "#FFFFFFBB";
    default_button_theme.bg_color_disabled = "#AAAAAA88";
    default_button_theme.font_color = "#000000";
    default_button_theme.font_color_highlight = "#000000";
    default_button_theme.font_color_disabled = "#555555";
    default_button_theme.font_outline_color = "#FFFFFF88";
    default_button_theme.font_outline_color_highlight = "#FFFFFFAA";
    default_button_theme.font_outline_color_disabled = "#787878";
    default_button_theme.outline = 0.1;
    // buttons
    if (include_resume) {
        __buttons_main_menu.emplace_back(std::make_shared<Button>(
            0.2, 0.25, 0.6, 0.1, renderer, "RESUME", default_button_theme,
            resumeMainMenuCallback, nullptr));
        __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
                                                 SDLPP::OBJ_CENTER);
        __buttons_main_menu.back()->setPermanent();
        __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() -
                                                   1);
    }
    if (include_restart || include_resume) {
        __buttons_main_menu.emplace_back(std::make_shared<Button>(
            0.2, 0.4, 0.6, 0.1, renderer, "RESTART", default_button_theme,
            restartMainMenuCallback, nullptr));
        __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
                                                 SDLPP::OBJ_CENTER);
        __buttons_main_menu.back()->setPermanent();
        __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() -
                                                   1);
    }
    __buttons_main_menu.emplace_back(
        std::make_shared<Button>(0.2, 0.55, 0.6, 0.1, renderer, "LOAD",
                                 default_button_theme, showLoadMenu, nullptr));
    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
                                             SDLPP::OBJ_CENTER);
    __buttons_main_menu.back()->setPermanent();
    __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
    __buttons_main_menu.emplace_back(std::make_shared<Button>(
        0.2, 0.85, 0.6, 0.1, renderer, "QUIT", default_button_theme,
        quitMainMenuCallback, nullptr));
    __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
                                             SDLPP::OBJ_CENTER);
    __buttons_main_menu.back()->setPermanent();
    __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
    for (auto &button : __buttons_main_menu) {
        scene->addObject(button);
    }
    return scene;
}

void additionalRenderMainMenu(std::shared_ptr<SDLPP::Scene> & /*UNUSED*/) {
    if (__update_scenes_main_menu) {
        for (auto &_scene : game_scenes) {
            _scene.scene->updateSizeAndPosition();
        }
        if (__started_main_menu) {
            __update_scenes_main_menu = false;
        } else {
            __started_main_menu = true;
        }
    }
    if (__quit_scenes_main_menu) {
        game_scenes.pop_back();
        game_scenes.back().scene->unpauseScene();
        if (__restart_scenes_main_menu) {
            loadLastLevel();
        }
        resetGlobals();
    }
}

void getMousePositionFlagsMainMenu(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);
    __updateSelectedButton_MainMenu(visitor.getCurButton());
}

void pollEventsMainMenu(std::shared_ptr<SDLPP::Scene> &scene) {
    SDL_Event event;
    while (SDLPP::getSDLEvent(event)) {
        switch (event.type) {
        case SDL_QUIT:
            quitMainMenu();
            break;
        case SDL_KEYUP:
            handleKeyUpMainMenu(event.key.keysym.sym, *scene);
            break;
        case SDL_WINDOWEVENT:
            if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
                __update_scenes_main_menu = true;
            }
            break;
        case SDL_MOUSEMOTION:
            getMousePositionFlagsMainMenu(*scene);
            break;
        case SDL_MOUSEBUTTONUP:
            if (__cur_button_index_main_menu_down ==
                    __cur_button_index_main_menu &&
                __cur_button_index_main_menu != (uint64_t)-1) {
                __buttons_main_menu[__cur_button_index_main_menu]
                    ->performFunction();
            }
            break;
        case SDL_MOUSEBUTTONDOWN:
            // store current mouse flags in previous mouse flags
            __cur_button_index_main_menu_down = __cur_button_index_main_menu;
            break;
        default:
            break;
        }
    }
}

SceneStruct createGameMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer,
                                    bool include_restart, bool include_resume,
                                    bool transparent_background) {
    __include_resume = include_resume;
    SceneStruct ret{};
    ret.scene = createSceneMainMenu(renderer, include_restart, include_resume,
                                    transparent_background);
    ret.additionalRender = additionalRenderMainMenu;
    ret.doInput = pollEventsMainMenu;
    __update_scenes_main_menu = true;
    __updateSelectedButton_MainMenu(0);
    return ret;
}