#include "cracker.hpp"

#include <lua/lua.hpp>
#include <spdlog/spdlog.h>
#include <sol/as_args.hpp>

#include "utils.hpp"

Cracker::Cracker()
    : m_state(lua_newthread(Utils::get_lua_state())) {}

Cracker& Cracker::Instance() {
    static auto* instance = new Cracker;
    return *instance;
}

void Cracker::disable_all() {
    disable_global_ship_properties_crack();
    disable_fast_stage_move();
    disable_remove_hard_mode_ship_properties_limit();
    disable_remove_hard_mode_ship_type_limit();
    disable_fake_player();
    disable_no_bb_animation();
    disable_no_emotion_warning();
    disable_opsi_fast_move();
}

void Cracker::enable_opsi_fast_move() {
    if (is_enabled(OPSI_FAST_MOVE)) {
        return;
    }
    m_original.WorldConst_BaseMoveDuration = m_state["WorldConst"]["BaseMoveDuration"];
    m_state["WorldConst"]["BaseMoveDuration"] = 0.0;
    enable_flag(OPSI_FAST_MOVE);
}

void Cracker::disable_opsi_fast_move() {
    if (is_disabled(OPSI_FAST_MOVE)) {
        return;
    }
    m_state["WorldConst"]["BaseMoveDuration"] = m_original.WorldConst_BaseMoveDuration;
    disable_flag(OPSI_FAST_MOVE);
}

void Cracker::enable_no_emotion_warning() {
    if (is_enabled(NO_EMOTION_WARNING)) {
        return;
    }
    m_original.Ship_cosumeEnergy = m_state["Ship"]["cosumeEnergy"];
    m_original.Ship_getEnergy = m_state["Ship"]["getEnergy"];

    m_state["Ship"]["cosumeEnergy"] = [](Lua::VariadicArgs args) -> Lua::Object {
        return sol::nil;
    };
    m_state["Ship"]["getEnergy"] = [](sol::this_state L, Lua::VariadicArgs args) -> Lua::Object {
        return sol::make_object(L, 150);
    };

    enable_flag(NO_EMOTION_WARNING);
}

void Cracker::disable_no_emotion_warning() {
    if (is_disabled(NO_EMOTION_WARNING)) {
        return;
    }
    m_state["Ship"]["cosumeEnergy"] = m_original.Ship_cosumeEnergy;
    m_state["Ship"]["getEnergy"] = m_original.Ship_getEnergy;
    disable_flag(NO_EMOTION_WARNING);
}

void Cracker::enable_no_bb_animation() {
    if (is_enabled(NO_BB_ANIMATION)) {
        return;
    }
    m_original.ys_Battle_BattleManualWeaponAutoBot_SetActive = m_state["ys"]["Battle"]["BattleManualWeaponAutoBot"]["SetActive"];
    m_state["ys"]["Battle"]["BattleManualWeaponAutoBot"]["SetActive"] = [this](sol::this_state L, Lua::VariadicArgs args) -> Lua::Object {
        std::vector<Lua::Object> new_args(args.begin(), args.end());
        new_args[2] = sol::make_object(L, false);
        Lua::Object res = m_original.ys_Battle_BattleManualWeaponAutoBot_SetActive(sol::as_args(new_args));
        return res;
    };
    enable_flag(NO_BB_ANIMATION);
}

void Cracker::disable_no_bb_animation() {
    if (is_disabled(NO_BB_ANIMATION)) {
        return;
    }
    m_state["ys"]["Battle"]["BattleManualWeaponAutoBot"]["SetActive"] = m_original.ys_Battle_BattleManualWeaponAutoBot_SetActive;
    disable_flag(NO_BB_ANIMATION);
}

void Cracker::enable_fake_player() {
    if (is_enabled(FAKE_PLAYER_INFO)) {
        return;
    }
    m_original.PlayerVitaeDetailPage_UpdateInfo = m_state["PlayerVitaeDetailPage"]["UpdateInfo"];
    m_state["PlayerVitaeDetailPage"]["UpdateInfo"] = [this](Lua::VariadicArgs args) -> Lua::Object {
        Lua::Object res = m_original.PlayerVitaeDetailPage_UpdateInfo(args);

        Lua::Table t = args[0];

        if (!m_fake_player_info.name.empty()) {
            t["nameTxt"]["text"] = m_fake_player_info.name;
        }
        if (!m_fake_player_info.level.empty()) {
            t["levelTxt"]["text"] = "LV." + m_fake_player_info.level;
        }
        if (!m_fake_player_info.id.empty()) {
            t["idTxt"]["text"] = m_fake_player_info.id;
        }

        return res;
    };
    enable_flag(FAKE_PLAYER_INFO);
}

void Cracker::disable_fake_player() {
    if (is_disabled(FAKE_PLAYER_INFO)) {
        return;
    }
    m_state["PlayerVitaeDetailPage"]["UpdateInfo"] = m_original.PlayerVitaeDetailPage_UpdateInfo;
    disable_flag(FAKE_PLAYER_INFO);
}

void Cracker::update_fake_player_info(const FakePlayerInfo& fake_info) {
    m_fake_player_info = fake_info;
}

void Cracker::enable_remove_hard_mode_ship_type_limit() {
    if (is_enabled(REMOVE_HARD_MODE_SHIP_TYPE_LIMIT)) {
        return;
    }
    m_original.Chapter_getConfig = m_state["Chapter"]["getConfig"];
    m_state["Chapter"]["getConfig"] = [this](sol::this_state L, Lua::VariadicArgs args) -> Lua::Object {
        Lua::Object first_arg = args[1];
        bool limitation = false;
        if (first_arg.get_type() == sol::type::string && first_arg.as<std::string>() == "limitation") {
            limitation = true;
        }

        Lua::Object res = m_original.Chapter_getConfig(args);

        if (limitation) {
            sol::table table = res;
            clear_hard_mode_ship_properties_limit(table);
        }
        return res;
    };
    enable_flag(REMOVE_HARD_MODE_SHIP_TYPE_LIMIT);
}

void Cracker::disable_remove_hard_mode_ship_type_limit() {
    if (is_disabled(REMOVE_HARD_MODE_SHIP_TYPE_LIMIT)) {
        return;
    }
    m_state["Chapter"]["getConfig"] = m_original.Chapter_getConfig;
    disable_flag(REMOVE_HARD_MODE_SHIP_TYPE_LIMIT);
}

void Cracker::enable_remove_hard_mode_ship_properties_limit() {
    if (is_enabled(REMOVE_HARD_MODE_SHIP_PROPERTIES_LIMIT)) {
        return;
    }

    m_original.WorldFleetSelectLayer_CheckValid = m_state["WorldFleetSelectLayer"]["CheckValid"];
    m_original.BossSingleBattleFleetSelectSubPanel_CheckValid = m_state["BossSingleBattleFleetSelectSubPanel"]["CheckValid"];
    m_original.Chapter_IsEliteFleetLegal = m_state["Chapter"]["IsEliteFleetLegal"];

    m_state["WorldFleetSelectLayer"]["CheckValid"] = [](Lua::VariadicArgs args) -> bool {
        return true;
    };
    m_state["BossSingleBattleFleetSelectSubPanel"]["CheckValid"] = [](Lua::VariadicArgs args) -> bool {
        return true;
    };
    m_state["Chapter"]["IsEliteFleetLegal"] = [](Lua::VariadicArgs args) -> bool {
        return true;
    };

    enable_flag(REMOVE_HARD_MODE_SHIP_PROPERTIES_LIMIT);
}

void Cracker::disable_remove_hard_mode_ship_properties_limit() {
    if (is_disabled(REMOVE_HARD_MODE_SHIP_PROPERTIES_LIMIT)) {
        return;
    }

    m_state["WorldFleetSelectLayer"]["CheckValid"] = m_original.WorldFleetSelectLayer_CheckValid;
    m_state["BossSingleBattleFleetSelectSubPanel"]["CheckValid"] = m_original.BossSingleBattleFleetSelectSubPanel_CheckValid;
    m_state["Chapter"]["IsEliteFleetLegal"] = m_original.Chapter_IsEliteFleetLegal;

    disable_flag(REMOVE_HARD_MODE_SHIP_PROPERTIES_LIMIT);
}

void Cracker::enable_fast_stage_move() {
    if (is_enabled(FAST_STAGE_MOVE_CRACK)) {
        return;
    }

    m_original.ChapterConst_ShipStepDuration = m_state["ChapterConst"]["ShipStepDuration"];
    m_original.ChapterConst_ShipStepQuickPlayScale = m_state["ChapterConst"]["ShipStepQuickPlayScale"];

    m_state["ChapterConst"]["ShipStepDuration"] = 0.0;
    m_state["ChapterConst"]["ShipStepQuickPlayScale"] = 0.0;

    enable_flag(FAST_STAGE_MOVE_CRACK);
}

void Cracker::disable_fast_stage_move() {
    if (is_disabled(FAST_STAGE_MOVE_CRACK)) {
        return;
    }

    m_state["ChapterConst"]["ShipStepDuration"] = m_original.ChapterConst_ShipStepDuration;
    m_state["ChapterConst"]["ShipStepQuickPlayScale"] = m_original.ChapterConst_ShipStepQuickPlayScale;

    disable_flag(FAST_STAGE_MOVE_CRACK);
}

void Cracker::update_global_ship_properties(const ShipProperties& properties) {
    m_globle_ship_properties = properties;
}

void Cracker::enable_global_ship_properties_crack() {
    if (is_enabled(GLOBAL_SHIP_PROPERTIES_CRACK)) {
        return;
    }
    m_original.Ship_getShipProperties = m_state["Ship"]["getShipProperties"];
    m_state["Ship"]["getShipProperties"] = [this](Lua::VariadicArgs args) -> Lua::Object {
        Lua::Table properties = m_original.Ship_getShipProperties(args);
        modify_ship_properties(properties, m_globle_ship_properties);
        return properties;
    };
    enable_flag(GLOBAL_SHIP_PROPERTIES_CRACK);
}

void Cracker::disable_global_ship_properties_crack() {
    if (is_disabled(GLOBAL_SHIP_PROPERTIES_CRACK)) {
        return;
    }
    m_state["Ship"]["getShipProperties"] = m_original.Ship_getShipProperties;
    disable_flag(GLOBAL_SHIP_PROPERTIES_CRACK);
}

bool Cracker::is_enabled(FunctionId id) {
    return m_functions.contains(id) ? m_functions[id] : false;
}

bool Cracker::is_disabled(FunctionId id) {
    return !is_enabled(id);
}

void Cracker::print_table_field(std::vector<std::string>& path) {
    Lua::Table t = m_state.globals();
    for (const auto& p : path) {
        t = t[p];
    }
    Utils::Lua::print_table_fields_type(t);
}

void Cracker::enable_flag(FunctionId id) {
    m_functions[id] = true;
}

void Cracker::disable_flag(FunctionId id) {
    m_functions[id] = false;
}

#define MODIFY_PROPERTY(name)                         \
    if (new_properties.name != -1) {                    \
        properties[#name] = new_properties.name;      \
    }

void Cracker::modify_ship_properties(Lua::Table& properties, const ShipProperties& new_properties) {
    MODIFY_PROPERTY(armor)
    MODIFY_PROPERTY(speed)
    MODIFY_PROPERTY(antiaircraft)
    MODIFY_PROPERTY(oxy_recovery_bench)
    MODIFY_PROPERTY(torpedo)
    MODIFY_PROPERTY(hit)
    MODIFY_PROPERTY(sonarRange)
    MODIFY_PROPERTY(attack_duration)
    MODIFY_PROPERTY(raid_distance)
    MODIFY_PROPERTY(oxy_recovery_surface)
    MODIFY_PROPERTY(oxy_recovery)
    MODIFY_PROPERTY(dodge)
    MODIFY_PROPERTY(luck)
    MODIFY_PROPERTY(reload)
    MODIFY_PROPERTY(oxy_cost)
    MODIFY_PROPERTY(durability)
    MODIFY_PROPERTY(air)
    MODIFY_PROPERTY(oxy_max)
    MODIFY_PROPERTY(cannon)
    MODIFY_PROPERTY(antisub)
}

void Cracker::clear_hard_mode_ship_properties_limit(Lua::Table& t) {
    for (int i = 1, n = t.size(); i <= n; ++i) {
        sol::table fleet = t[i];
        for (int j = 1, m = fleet.size(); j <= m; ++j) {
            sol::table team = fleet[j];
            for (int k = 1, l = team.size(); k <= l; ++k) {
                team[k] = 0.0;
            }
        }
    }
}