#include "RocksDBWrapper.h"
#include <gtest/gtest.h>
#include <string>
#include <filesystem>

struct TestStruct
{
    int id;
    std::string name;
    double value;

    DEFINE_SERIALIZABLE(TestStruct, id, name, value);
};

class RocksDBWrapperTest : public ::testing::Test
{
protected:
    RocksDBWrapper *db;
    std::string db_path = "/tmp/testdb";
    std::string index_path = "/tmp/testindex";

    void SetUp() override
    {
        db = new RocksDBWrapper(db_path, index_path);
    }

    void TearDown() override
    {
        delete db;
        // Clean up the database files after each test
        std::filesystem::remove_all(db_path);
        std::filesystem::remove_all(index_path);
    }
};

TEST_F(RocksDBWrapperTest, StoreAndRetrieve)
{
    TestStruct original{1, "Test", 3.14};
    db->store("test_key", original);

    TestStruct retrieved;
    bool found = db->get("test_key", retrieved);

    ASSERT_TRUE(found);
    EXPECT_EQ(original.id, retrieved.id);
    EXPECT_EQ(original.name, retrieved.name);
    EXPECT_DOUBLE_EQ(original.value, retrieved.value);
}

TEST_F(RocksDBWrapperTest, KeyExists)
{
    TestStruct original{2, "AnotherTest", 2.718};
    db->store("another_key", original);

    ASSERT_TRUE(db->keyExists("another_key"));
    ASSERT_FALSE(db->keyExists("nonexistent_key"));
}

TEST_F(RocksDBWrapperTest, SearchByMember)
{
    TestStruct ts1{1, "Alpha", 1.1};
    TestStruct ts2{2, "Beta", 2.2};
    TestStruct ts3{3, "Gamma", 3.3};

    db->store("key1", ts1);
    db->store("key2", ts2);
    db->store("key3", ts3);

    auto keys = db->search<TestStruct>("name", "Beta");
    ASSERT_EQ(keys.size(), 1);
    EXPECT_EQ(keys[0], "key2");
}

TEST_F(RocksDBWrapperTest, SearchText)
{
    TestStruct ts1{1, "Alpha", 1.1};
    TestStruct ts2{2, "Beta", 2.2};
    TestStruct ts3{3, "Gamma", 3.3};

    db->store("key1", ts1);
    db->store("key2", ts2);
    db->store("key3", ts3);

    std::vector<TestStruct> results;
    db->search_text("Bet*", results);

    ASSERT_EQ(results.size(), 1);
    EXPECT_EQ(results[0].name, "Beta");
}

TEST_F(RocksDBWrapperTest, ConditionalSearch)
{
    TestStruct ts1{1, "Alpha", 1.1};
    TestStruct ts2{2, "Beta", 2.2};
    TestStruct ts3{3, "Gamma", 3.3};

    db->store("key1", ts1);
    db->store("key2", ts2);
    db->store("key3", ts3);

    std::vector<TestStruct> results;
    db->search_conditional<TestStruct>(results, [](const TestStruct &s)
                                       { return s.value > 2.0; });

    ASSERT_EQ(results.size(), 2);
    EXPECT_EQ(results[0].name, "Beta");
    EXPECT_EQ(results[1].name, "Gamma");
}

int main(int argc, char **argv)
{
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}