warfactoryracine/modules/debug-world-gen/src/DebugWorldGenModuleLight.cpp

#include <warfactory/IModule.h>
#include <warfactory/IIO.h>
#include <nlohmann/json.hpp>
#include <iostream>
#include <memory>
#include <string>

using json = nlohmann::json;

namespace warfactory {

/**
 * @brief ULTRA-LIGHT Debug World Generation Module
 *
 * Minimal version for testing hot-reload without heavy dependencies.
 * No spdlog, no file logging, just stdout and core functionality.
 */
class DebugWorldGenModuleLight : public IModule {
private:
    IIO* io = nullptr;
    ITaskScheduler* taskScheduler = nullptr;

    // Minimal state
    json config;
    int chunksGenerated = 0;
    bool initialized = false;

public:
    DebugWorldGenModuleLight() {
        std::cout << "🌍 LIGHT Debug World Gen Module created - HOT RELOAD TEST!" << std::endl;
    }

    virtual ~DebugWorldGenModuleLight() {
        std::cout << "🌍 Light module destroyed (chunks: " << chunksGenerated << ")" << std::endl;
    }

    void initialize(const json& moduleConfig, IIO* ioService, ITaskScheduler* scheduler) override {
        std::cout << "🚀 Initializing LIGHT module..." << std::endl;

        io = ioService;
        taskScheduler = scheduler;

        if (moduleConfig.empty()) {
            config = {{"seed", 42}, {"size", 100}};
            std::cout << "📋 Using default config" << std::endl;
        } else {
            config = moduleConfig;
            std::cout << "📋 Config loaded: " << config.dump() << std::endl;
        }

        // Subscribe to minimal topics
        io->subscribe("world:request:chunk", {});
        std::cout << "📨 Subscribed to chunk requests" << std::endl;

        initialized = true;
        std::cout << "✅ Light module initialized" << std::endl;
    }

    void process(const json& input) override {
        if (!initialized) return;

        // Process messages
        while (io->hasMessages() > 0) {
            Message msg = io->pullMessage();
            std::cout << "📥 Processing: " << msg.topic << std::endl;

            if (msg.topic == "world:request:chunk") {
                // Generate simple chunk
                int x = msg.data.value("chunk_x", 0);
                int y = msg.data.value("chunk_y", 0);

                json chunk = {
                    {"chunk_x", x},
                    {"chunk_y", y},
                    {"data", "generated_chunk_" + std::to_string(++chunksGenerated)}
                };

                std::string responseTopic = "world:chunk:" + std::to_string(x) + ":" + std::to_string(y);
                io->publish(responseTopic, chunk);

                std::cout << "📤 Generated chunk [" << x << "," << y << "] (#" << chunksGenerated << ")" << std::endl;
            }
        }
    }

    void shutdown() override {
        std::cout << "🛑 Shutting down light module" << std::endl;
        initialized = false;
    }

    json getState() override {
        return {
            {"config", config},
            {"chunks_generated", chunksGenerated},
            {"initialized", initialized}
        };
    }

    void setState(const json& state) override {
        std::cout << "🔄 Restoring state (hot-reload)" << std::endl;

        if (state.contains("config")) {
            config = state["config"];
        }
        if (state.contains("chunks_generated")) {
            chunksGenerated = state["chunks_generated"];
        }
        if (state.contains("initialized")) {
            initialized = state["initialized"];
        }

        std::cout << "✅ State restored: " << chunksGenerated << " chunks" << std::endl;
    }

    std::string getType() const override {
        return "debug-world-gen-light";
    }
};

} // namespace warfactory

// Module entry points
extern "C" {
    warfactory::IModule* create_module() {
        return new warfactory::DebugWorldGenModuleLight();
    }

    void destroy_module(warfactory::IModule* module) {
        delete module;
    }

    const char* get_module_type() {
        return "debug-world-gen-light";
    }

    const char* get_module_version() {
        return "1.0.0-light";
    }
}