#include "ModuleManager.h"

#include "ESP.h"
#include "FPSModule.h"
#include "FreeCam.h"
#include "FpsUnlocker.h"
#include "NoClip.h"
#include "PlayerProfile.h"
#include "PreventScreenshot.h"
#include "SetDither.h"
#include "SkillHack.h"
#include "UnityExplorer.h"
#include "Vacuum.h"
#include "helpers.h"

void ModuleManager::AddRegistrar(const std::string& name, ModuleFactory factory) {
    registrars_.emplace_back(name, std::move(factory));
}

void ModuleManager::Init() {
    if (initialized_) {
        Log("[WARNING] ModuleManager already initialized");
        return;
    }

    Log("Initializing ModuleManager");

    for (const auto& registrar : registrars_) {
        try {
            std::unique_ptr<BaseModule> module = registrar.second();
            if (!module) {
                Log("Failed to initialize module %s", registrar.first.c_str());
                continue;
            }
            module->RegisterTab();
            Log("Module %s initialized", module->Name().c_str());
            modules_.push_back(std::move(module));
        } catch (...) {
            Log("Failed to initialize module %s", registrar.first.c_str());
        }
    }

    initialized_ = true;
    Log("ModuleManager initialization complete");
}

void ModuleManager::DispatchRenderByTab(MainTab tab) {
    if (!initialized_) {
        return;
    }

    auto render_for_category = [&](ModuleCategory category) {
        for (const auto& module : modules_) {
            if (!module || module->Category() != category) {
                continue;
            }
            try {
                module->Render();
            } catch (...) {
                Log("[ERROR] Failed to render overlay for module %s", module->Name().c_str());
            }
        }
    };

    switch (tab) {
    case MainTab::Player:
        render_for_category(ModuleCategory::Player);
        break;
    case MainTab::ESP:
        render_for_category(ModuleCategory::ESP);
        break;
    case MainTab::World:
        render_for_category(ModuleCategory::World);
        break;
    case MainTab::Visual:
        render_for_category(ModuleCategory::Visual);
        break;
    default:
        break;
    }
}

void ModuleManager::DispatchUpdate() {
    if (!initialized_) {
        return;
    }

    for (const auto& module : modules_) {
        if (!module || !module->Enabled()) {
            continue;
        }
        try {
            module->Update();
        } catch (...) {
            Log("[ERROR] Failed to update module %s", module->Name().c_str());
        }
    }
}

void ModuleManager::DispatchHotkeys() {
    if (!initialized_) {
        return;
    }

    for (const auto& module : modules_) {
        if (!module || !module->Enabled()) {
            continue;
        }
        try {
            module->OnHotkey();
        } catch (...) {
            Log("[ERROR] Failed to process hotkeys for module %s", module->Name().c_str());
        }
    }
}

BaseModule* ModuleManager::FindModule(const std::string& name) {
    for (const auto& module : modules_) {
        if (module && module->Name() == name) {
            return module.get();
        }
    }
    return nullptr;
}

std::vector<BaseModule*> ModuleManager::GetModulesByCategory(ModuleCategory category) {
    std::vector<BaseModule*> result;
    for (const auto& module : modules_) {
        if (module && module->Category() == category) {
            result.push_back(module.get());
        }
    }
    return result;
}

ModuleManager& GetModuleManager() {
    static ModuleManager manager;
    return manager;
}

void RegisterDefaultModules() {
    ModuleManager& manager = GetModuleManager();

    manager.AddRegistrar("SetDither", []() { return std::make_unique<SetDitherModule>(); });
    manager.AddRegistrar("SkillHack", []() { return std::make_unique<SkillHackModule>(); });
    manager.AddRegistrar("PlayerProfile", []() { return std::make_unique<PlayerProfileModule>(); });
    manager.AddRegistrar("NoClip", []() { return std::make_unique<NoClipModule>(); });
    manager.AddRegistrar("Vacuum", []() { return std::make_unique<VacuumModule>(); });
    manager.AddRegistrar("UnityExplorerModule", []() { return std::make_unique<UnityExplorerModule>(); });
    manager.AddRegistrar("FpsUnlocker", []() { return std::make_unique<FpsUnlockerModule>(); });
    manager.AddRegistrar("FPSModule", []() { return std::make_unique<FPSModule>(); });
    manager.AddRegistrar("FreeCam", []() { return std::make_unique<FreeCamModule>(); });
    manager.AddRegistrar("ESPModule", []() { return std::make_unique<ESPModule>(); });
    manager.AddRegistrar("PreventScreenshot", []() { return std::make_unique<PreventScreenshotModule>(); });
}