/**
 * Integration Test IT_014: UIModule Full Integration
 *
 * Tests complete UI system integration:
 * - BgfxRenderer module (rendering backend)
 * - UIModule (UI widgets and layout)
 * - TestControllerModule (simulates game logic)
 *
 * Verifies:
 * - All modules load and communicate via IIO
 * - UI events trigger game logic
 * - Game logic updates UI state
 * - Mouse/keyboard input flows correctly
 * - Tooltips and scrolling work
 */

#include <catch2/catch_test_macros.hpp>
#include <grove/ModuleLoader.h>
#include <grove/IntraIOManager.h>
#include <grove/IntraIO.h>
#include <grove/JsonDataNode.h>

#include <thread>
#include <chrono>
#include <iostream>

using namespace grove;

TEST_CASE("IT_014: UIModule Full Integration", "[integration][ui][phase7]") {
    std::cout << "\n========================================\n";
    std::cout << "IT_014: UIModule Full Integration Test\n";
    std::cout << "========================================\n\n";

    auto& ioManager = IntraIOManager::getInstance();

    // Create IIO instances for each module
    auto rendererIO = ioManager.createInstance("bgfx_renderer");
    auto uiIO = ioManager.createInstance("ui_module");
    auto gameIO = ioManager.createInstance("game_logic");

    SECTION("Load all modules") {
        ModuleLoader rendererLoader;
        ModuleLoader uiLoader;
        ModuleLoader gameLoader;

        std::string rendererPath = "../modules/libBgfxRenderer.so";
        std::string uiPath = "../modules/libUIModule.so";
        std::string gamePath = "./libTestControllerModule.so";

#ifdef _WIN32
        rendererPath = "../modules/BgfxRenderer.dll";
        uiPath = "../modules/UIModule.dll";
        gamePath = "./TestControllerModule.dll";
#endif

        SECTION("Load BgfxRenderer") {
            std::unique_ptr<IModule> renderer;
            REQUIRE_NOTHROW(renderer = rendererLoader.load(rendererPath, "bgfx_renderer"));
            REQUIRE(renderer != nullptr);

            // Configure headless renderer
            JsonDataNode config("config");
            config.setInt("windowWidth", 800);
            config.setInt("windowHeight", 600);
            config.setString("backend", "noop");  // Headless mode
            config.setBool("vsync", false);

            REQUIRE_NOTHROW(renderer->setConfiguration(config, rendererIO.get(), nullptr));

            std::cout << "✅ BgfxRenderer loaded and configured\n";

            SECTION("Load UIModule") {
                std::unique_ptr<IModule> uiModule;
                REQUIRE_NOTHROW(uiModule = uiLoader.load(uiPath, "ui_module"));
                REQUIRE(uiModule != nullptr);

                // Configure UI with test layout
                JsonDataNode uiConfig("config");
                uiConfig.setInt("windowWidth", 800);
                uiConfig.setInt("windowHeight", 600);
                uiConfig.setString("layoutFile", "../../assets/ui/test_widgets.json");
                uiConfig.setInt("baseLayer", 1000);

                REQUIRE_NOTHROW(uiModule->setConfiguration(uiConfig, uiIO.get(), nullptr));

                std::cout << "✅ UIModule loaded and configured\n";

                SECTION("Load TestControllerModule") {
                    std::unique_ptr<IModule> gameModule;
                    REQUIRE_NOTHROW(gameModule = gameLoader.load(gamePath, "game_logic"));
                    REQUIRE(gameModule != nullptr);

                    // Configure game controller
                    JsonDataNode gameConfig("config");
                    gameConfig.setString("uiInstanceId", "ui_module");

                    REQUIRE_NOTHROW(gameModule->setConfiguration(gameConfig, gameIO.get(), nullptr));

                    std::cout << "✅ TestControllerModule loaded and configured\n";

                    SECTION("Run integration loop") {
                        std::cout << "\n--- Running Integration Loop ---\n";

                        // Subscribe to events we want to verify
                        gameIO->subscribe("ui:click");
                        gameIO->subscribe("ui:action");
                        gameIO->subscribe("ui:value_changed");
                        gameIO->subscribe("ui:hover");

                        int clickCount = 0;
                        int actionCount = 0;
                        int valueChangeCount = 0;
                        int hoverCount = 0;

                        // Simulate 60 frames (~1 second at 60fps)
                        for (int frame = 0; frame < 60; frame++) {
                            // Simulate mouse movement
                            if (frame == 10) {
                                auto mouseMove = std::make_unique<JsonDataNode>("mouse_move");
                                mouseMove->setDouble("x", 400.0);
                                mouseMove->setDouble("y", 300.0);
                                uiIO->publish("input:mouse:move", std::move(mouseMove));
                            }

                            // Simulate mouse click on button
                            if (frame == 20) {
                                auto mouseDown = std::make_unique<JsonDataNode>("mouse_button");
                                mouseDown->setInt("button", 0);
                                mouseDown->setBool("pressed", true);
                                mouseDown->setDouble("x", 400.0);
                                mouseDown->setDouble("y", 300.0);
                                uiIO->publish("input:mouse:button", std::move(mouseDown));
                            }

                            if (frame == 22) {
                                auto mouseUp = std::make_unique<JsonDataNode>("mouse_button");
                                mouseUp->setInt("button", 0);
                                mouseUp->setBool("pressed", false);
                                mouseUp->setDouble("x", 400.0);
                                mouseUp->setDouble("y", 300.0);
                                uiIO->publish("input:mouse:button", std::move(mouseUp));
                            }

                            // Simulate mouse wheel
                            if (frame == 30) {
                                auto mouseWheel = std::make_unique<JsonDataNode>("mouse_wheel");
                                mouseWheel->setDouble("delta", 1.0);
                                uiIO->publish("input:mouse:wheel", std::move(mouseWheel));
                            }

                            // Process all modules
                            JsonDataNode frameInput("input");
                            frameInput.setDouble("deltaTime", 1.0 / 60.0);

                            uiModule->process(frameInput);
                            gameModule->process(frameInput);
                            renderer->process(frameInput);

                            // Check for events
                            while (gameIO->hasMessages() > 0) {
                                auto msg = gameIO->pullMessage();

                                if (msg.topic == "ui:click") {
                                    clickCount++;
                                    std::cout << "  Frame " << frame << ": Click event received\n";
                                }
                                else if (msg.topic == "ui:action") {
                                    actionCount++;
                                    std::string action = msg.data->getString("action", "");
                                    std::cout << "  Frame " << frame << ": Action event: " << action << "\n";
                                }
                                else if (msg.topic == "ui:value_changed") {
                                    valueChangeCount++;
                                    std::cout << "  Frame " << frame << ": Value changed\n";
                                }
                                else if (msg.topic == "ui:hover") {
                                    bool enter = msg.data->getBool("enter", false);
                                    if (enter) {
                                        hoverCount++;
                                        std::cout << "  Frame " << frame << ": Hover event\n";
                                    }
                                }
                            }

                            // Small delay to simulate real-time
                            std::this_thread::sleep_for(std::chrono::milliseconds(1));
                        }

                        std::cout << "\n--- Integration Loop Complete ---\n";
                        std::cout << "Events received:\n";
                        std::cout << "  Clicks: " << clickCount << "\n";
                        std::cout << "  Actions: " << actionCount << "\n";
                        std::cout << "  Value changes: " << valueChangeCount << "\n";
                        std::cout << "  Hovers: " << hoverCount << "\n";

                        // Verify we got some interaction
                        REQUIRE(hoverCount > 0);  // Should have hover events
                        // Note: Clicks might not work in headless mode depending on layout

                        std::cout << "\n✅ Integration loop successful\n";
                    }

                    SECTION("Verify module health") {
                        auto uiHealth = uiModule->getHealthStatus();
                        REQUIRE(uiHealth != nullptr);
                        REQUIRE(uiHealth->getString("status", "") == "healthy");

                        auto gameHealth = gameModule->getHealthStatus();
                        REQUIRE(gameHealth != nullptr);
                        REQUIRE(gameHealth->getString("status", "") == "healthy");

                        std::cout << "✅ All modules healthy\n";
                    }

                    SECTION("Test state save/restore") {
                        // Get state from game module
                        auto state = gameModule->getState();
                        REQUIRE(state != nullptr);

                        // Modify and restore
                        gameModule->setState(*state);

                        std::cout << "✅ State save/restore works\n";
                    }

                    // Cleanup game module
                    gameModule->shutdown();
                    gameLoader.unload();
                }

                // Cleanup UI module
                uiModule->shutdown();
                uiLoader.unload();
            }

            // Cleanup renderer
            renderer->shutdown();
            rendererLoader.unload();
        }
    }

    // Cleanup IIO instances
    ioManager.removeInstance("bgfx_renderer");
    ioManager.removeInstance("ui_module");
    ioManager.removeInstance("game_logic");

    std::cout << "\n========================================\n";
    std::cout << "✅ IT_014 PASSED - Full Integration OK\n";
    std::cout << "========================================\n";
}