#include <shared/testing/ITestModule.h>
#include <grove/JsonDataNode.h>
#include <grove/IIO.h>
#include <spdlog/spdlog.h>
#include <chrono>
#include <thread>
#include <filesystem>
#include <fstream>

namespace fs = std::filesystem;

namespace aissia::testing {

/**
 * @brief Test Storage read via AI tool
 *
 * Workflow:
 * 1. Create a test note file
 * 2. Ask AI to query notes using storage_query_notes
 * 3. Verify AI returns the note content
 */
class IT_008_StorageRead : public ITestModule {
public:
    std::string getTestName() const override {
        return "IT_008_StorageRead";
    }

    std::string getDescription() const override {
        return "Test Storage read via AI tool";
    }

    void setConfiguration(const grove::IDataNode& config,
                         grove::IIO* io,
                         grove::ITaskScheduler* scheduler) override {
        m_io = io;
        m_scheduler = scheduler;
        m_timeout = config.getInt("timeoutMs", 30000);

        grove::SubscriptionConfig subConfig;
        m_io->subscribe("llm:response", subConfig);
        m_io->subscribe("llm:error", subConfig);

        spdlog::info("[{}] Configured", getTestName());
    }

    void process(const grove::IDataNode& input) override {}
    void shutdown() override {}

    const grove::IDataNode& getConfiguration() override {
        static grove::JsonDataNode config("config");
        return config;
    }

    std::unique_ptr<grove::IDataNode> getHealthStatus() override {
        auto status = std::make_unique<grove::JsonDataNode>("health");
        status->setString("status", "healthy");
        return status;
    }

    std::unique_ptr<grove::IDataNode> getState() override {
        return std::make_unique<grove::JsonDataNode>("state");
    }

    void setState(const grove::IDataNode& state) override {}

    std::string getType() const override { return "IT_008_StorageRead"; }
    int getVersion() const override { return 1; }
    bool isIdle() const override { return true; }

    TestResult execute() override {
        auto start = std::chrono::steady_clock::now();
        TestResult result;
        result.testName = getTestName();

        const std::string testContent = "IT_008 test data for storage read";
        const std::string testFile = "data/notes/test_it008.md";

        try {
            // 1. Create test note
            fs::create_directories("data/notes");
            std::ofstream file(testFile);
            file << "# Test Note IT008\n\n" << testContent;
            file.close();
            spdlog::info("[{}] Created test note: {}", getTestName(), testFile);

            // 2. Ask AI to query notes
            spdlog::info("[{}] Asking AI to query notes...", getTestName());
            auto request = std::make_unique<grove::JsonDataNode>("request");
            request->setString("query",
                "Utilise le tool storage_query_notes pour chercher les notes contenant 'IT_008'");
            request->setString("conversationId", "it008");
            m_io->publish("ai:query", std::move(request));

            // 3. Wait for response
            auto response = waitForMessage("llm:response", m_timeout);

            if (!response) {
                auto error = waitForMessage("llm:error", 1000);
                if (error) {
                    result.passed = false;
                    result.message = "LLM error: " + error->getString("message", "Unknown");
                } else {
                    result.passed = false;
                    result.message = "Timeout waiting for llm:response";
                }
                // Cleanup
                if (fs::exists(testFile)) fs::remove(testFile);
                return result;
            }

            std::string text = response->getString("text", "");
            spdlog::info("[{}] LLM response: {}", getTestName(), text);

            // 4. Verify response contains our test data
            bool contentFound = text.find("IT_008") != std::string::npos ||
                               text.find("test data") != std::string::npos;

            result.passed = contentFound;
            result.message = contentFound ?
                "Note retrieved successfully" :
                "Note content not found in response";
            result.details["response"] = text;
            result.details["expectedContent"] = testContent;

            // Cleanup
            if (fs::exists(testFile)) {
                fs::remove(testFile);
            }

        } catch (const std::exception& e) {
            result.passed = false;
            result.message = std::string("Exception: ") + e.what();
            spdlog::error("[{}] {}", getTestName(), result.message);

            // Cleanup on error
            if (fs::exists(testFile)) fs::remove(testFile);
        }

        auto end = std::chrono::steady_clock::now();
        result.durationMs = std::chrono::duration_cast<std::chrono::milliseconds>(
            end - start).count();

        return result;
    }

private:
    std::unique_ptr<grove::IDataNode> waitForMessage(
        const std::string& topic, int timeoutMs) {

        auto start = std::chrono::steady_clock::now();

        while (true) {
            if (m_io->hasMessages() > 0) {
                auto msg = m_io->pullMessage();
                if (msg.topic == topic && msg.data) {
                    return std::move(msg.data);
                }
            }

            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
                std::chrono::steady_clock::now() - start).count();

            if (elapsed > timeoutMs) {
                return nullptr;
            }

            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    }

    grove::IIO* m_io = nullptr;
    grove::ITaskScheduler* m_scheduler = nullptr;
    int m_timeout = 30000;
};

} // namespace aissia::testing

extern "C" {
    grove::IModule* createModule() {
        return new aissia::testing::IT_008_StorageRead();
    }

    void destroyModule(grove::IModule* module) {
        delete module;
    }
}