#include "gtest/gtest.h"
#include "db/NewDB.h"  // NewDB 的头文件
#include "leveldb/env.h"
#include "leveldb/db.h"
#include <iostream>
#include <random>
#include <ctime>
#include <chrono>  // 用于计时
#include <vector>  // 用于存储延迟
using namespace std;
using namespace leveldb;

Status OpenDB(std::string dbName, NewDB** db) {
    Options options = Options();
    options.create_if_missing = true;
    return NewDB::Open(options, dbName, db);
}

// 全局的随机数引擎
std::default_random_engine rng;

// 设置随机种子
void SetGlobalSeed(unsigned seed) {
    rng.seed(seed);
}

// 生成随机字符串
std::string GenerateRandomString(size_t length) {
    static const char alphanum[] =
        "0123456789"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz";

    std::uniform_int_distribution<int> dist(0, sizeof(alphanum) - 2);

    std::string str(length, 0);
    for (size_t i = 0; i < length; ++i) {
        str[i] = alphanum[dist(rng)];
    }
    return str;
}

std::string testdbname = "testdb2";

// TEST(TestNewDB, PersistentIndexTest) {
//     // 创建 NewDB 实例
//     NewDB* db;
//     ASSERT_TRUE(OpenDB(testdbname, &db).ok());

//     // 批量插入数据
//     std::vector<std::pair<std::string, FieldArray>> bulk_data;
//     const int num_records = 1000;  // 适当减少记录数，以便测试

//     for (int i = 0; i < num_records; ++i) {
//         std::string key = "k_" + GenerateRandomString(10);
//         FieldArray fields = {
//             {"name", GenerateRandomString(10)},
//             {"address", GenerateRandomString(25)},
//             {"phone", GenerateRandomString(11)}
//         };
//         bulk_data.emplace_back(key, fields);

//         ASSERT_TRUE(db->Put_fields(WriteOptions(), key, fields).ok());
//     }

//     // 创建索引字段
//     db->CreateIndexOnField("address");

//     // 关闭数据库
//     delete db;

//     // 重新打开数据库
//     ASSERT_TRUE(OpenDB(testdbname, &db).ok());

//     // 验证索引字段是否仍然存在
//     for (const auto& [key, fields] : bulk_data) {
//         // 获取并验证字段数据
//         FieldArray retrieved_fields;
//         ASSERT_TRUE(db->Get_fields(ReadOptions(), Slice(key), &retrieved_fields).ok());
//         EXPECT_EQ(retrieved_fields.size(), fields.size());

//         // 验证索引是否能正确找到对应的键
//         Field field_to_query{"address", fields[1].second}; // 使用 address 字段进行查询
//         std::vector<std::string> matching_keys = db->QueryByIndex(field_to_query);

//         EXPECT_FALSE(matching_keys.empty()); // 应该能找到对应的键
//         EXPECT_NE(std::find(matching_keys.begin(), matching_keys.end(), key), matching_keys.end());
//     }

//     // 关闭数据库
//     delete db;
// }

// TEST(TestNewDB, BulkCreateIndexAndQueryTest) {
//     // 创建 NewDB 实例
//     NewDB* db;
//     ASSERT_TRUE(OpenDB(testdbname, &db).ok());

//     // 批量插入数据
//     std::vector<std::pair<std::string, FieldArray>> bulk_data;
//     const int num_records = 10000;

//     for (int i = 0; i < num_records; ++i) {
//         std::string key = "k_" + GenerateRandomString(10);
//         FieldArray fields = {
//             {"name", GenerateRandomString(10)},
//             {"address", GenerateRandomString(25)},
//             {"phone", GenerateRandomString(11)}
//         };
//         bulk_data.emplace_back(key, fields);

//         ASSERT_TRUE(db->Put_fields(WriteOptions(), key, fields).ok());
//     }

//     // 创建索引字段
//     db->CreateIndexOnField("address");

//     // 验证插入的数据和索引
//     for (const auto& [key, fields] : bulk_data) {
//         // 获取并验证字段数据
//         FieldArray retrieved_fields;
//         ASSERT_TRUE(db->Get_fields(ReadOptions(), Slice(key), &retrieved_fields).ok());
//         EXPECT_EQ(retrieved_fields.size(), fields.size());

//         // 验证插入的每个字段
//         for (size_t i = 0; i < fields.size(); ++i) {
//             // EXPECT_EQ(fields[i].first, retrieved_fields[i].first);  // 字段名
//             // EXPECT_EQ(fields[i].second, retrieved_fields[i].second); // 字段值
//         if (fields[i].second != retrieved_fields[i].second) {
//                 std::cerr << "Mismatch at index: " << i
//                             << ", Key: " << key
//                             << ", Field Name: " << fields[i].first
//                             << ", Expected: " << fields[i].second
//                             << ", Retrieved: " << retrieved_fields[i].second
//                             << std::endl;
//     }
//         }

//         // 验证索引是否能正确找到对应的键
//         Field field_to_query{"address", fields[1].second}; // 使用 address 字段进行查询
//         std::vector<std::string> matching_keys = db->QueryByIndex(field_to_query);
//         EXPECT_FALSE(matching_keys.empty()); // 应该能找到对应的键
//         EXPECT_NE(std::find(matching_keys.begin(), matching_keys.end(), key), matching_keys.end());
//     }

//     delete db;
// }

TEST(TestNewDB, QueryByIndexPerformance) {
    // 创建 NewDB 实例
    NewDB* db;
    ASSERT_TRUE(OpenDB(testdbname, &db).ok());

    // 批量插入数据
    std::vector<std::pair<std::string, FieldArray>> bulk_data;
    const int num_records = 10000;

    for (int i = 0; i < num_records; ++i) {
        std::string key = "k_" + GenerateRandomString(10);
        FieldArray fields = {
            {"name", GenerateRandomString(10)},
            {"address", GenerateRandomString(25)},
            {"phone", GenerateRandomString(11)}
        };
        bulk_data.emplace_back(key, fields);

        ASSERT_TRUE(db->Put_fields(WriteOptions(), key, fields).ok());
    }

    // 创建索引字段
    db->CreateIndexOnField("address");
    // 测试查询延迟
    auto start_time = std::chrono::high_resolution_clock::now();  // 记录开始时间
    // 验证插入的数据和索引
    for (const auto& [key, fields] : bulk_data) {
        // 获取并验证字段数据
        FieldArray retrieved_fields;
        ASSERT_TRUE(db->Get_fields(ReadOptions(), Slice(key), &retrieved_fields).ok());
        EXPECT_EQ(retrieved_fields.size(), fields.size());

        // 验证插入的每个字段
        // for (size_t i = 0; i < fields.size(); ++i) {
        //     // EXPECT_EQ(fields[i].first, retrieved_fields[i].first);  // 字段名
        //     // EXPECT_EQ(fields[i].second, retrieved_fields[i].second); // 字段值
        // if (fields[i].second != retrieved_fields[i].second) {
        //         std::cerr << "Mismatch at index: " << i
        //                     << ", Key: " << key
        //                     << ", Field Name: " << fields[i].first
        //                     << ", Expected: " << fields[i].second
        //                     << ", Retrieved: " << retrieved_fields[i].second
        //                     << std::endl;
        //     }
        // }

        // 验证索引是否能正确找到对应的键
        Field field_to_query{"address", fields[1].second}; // 使用 address 字段进行查询
        std::vector<std::string> matching_keys = db->QueryByIndex(field_to_query);

        EXPECT_FALSE(matching_keys.empty()); // 应该能找到对应的键
        EXPECT_NE(std::find(matching_keys.begin(), matching_keys.end(), key), matching_keys.end());
    }
    auto end_time = std::chrono::high_resolution_clock::now();  // 记录结束时间
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
    cout << "Throughput: " << num_records * 1000 / duration << " OPS" << endl;
    cout << "Total Latency " << duration << " ms" << endl;
    delete db;
}

// TEST(TestNewDB, FindKeysByFieldPerformance) {
//     // 创建 NewDB 实例
//     NewDB* db;
//     ASSERT_TRUE(OpenDB(testdbname, &db).ok());

//     // 批量插入数据
//     std::vector<std::pair<std::string, FieldArray>> bulk_data;
//     const int num_records = 100000;

//     for (int i = 0; i < num_records; ++i) {
//         std::string key = "k_" + GenerateRandomString(10);
//         FieldArray fields = {
//             {"name", GenerateRandomString(10)},
//             {"address", GenerateRandomString(25)},
//             {"phone", GenerateRandomString(11)}
//         };
//         bulk_data.emplace_back(key, fields);

//         ASSERT_TRUE(db->Put_fields(WriteOptions(), key, fields).ok());
//     }

//     // 创建索引字段
//     db->CreateIndexOnField("address");
//     // 测试查询延迟
//     auto start_time = std::chrono::high_resolution_clock::now();  // 记录开始时间
//     // 验证插入的数据和索引
//     for (const auto& [key, fields] : bulk_data) {
//         // 获取并验证字段数据
//         FieldArray retrieved_fields;
//         ASSERT_TRUE(db->Get_fields(ReadOptions(), Slice(key), &retrieved_fields).ok());
//         EXPECT_EQ(retrieved_fields.size(), fields.size());

//         // 验证插入的每个字段
//         // for (size_t i = 0; i < fields.size(); ++i) {
//         //     // EXPECT_EQ(fields[i].first, retrieved_fields[i].first);  // 字段名
//         //     // EXPECT_EQ(fields[i].second, retrieved_fields[i].second); // 字段值
//         // if (fields[i].second != retrieved_fields[i].second) {
//         //         std::cerr << "Mismatch at index: " << i
//         //                     << ", Key: " << key
//         //                     << ", Field Name: " << fields[i].first
//         //                     << ", Expected: " << fields[i].second
//         //                     << ", Retrieved: " << retrieved_fields[i].second
//         //                     << std::endl;
//         //     }
//         // }

//         // 验证索引是否能正确找到对应的键
//         Field field_to_query{"address", fields[1].second}; // 使用 address 字段进行查询
//         std::vector<std::string> matching_keys = db->FindKeysByField(field_to_query);

//         EXPECT_FALSE(matching_keys.empty()); // 应该能找到对应的键
//         EXPECT_NE(std::find(matching_keys.begin(), matching_keys.end(), key), matching_keys.end());
//     }
//     auto end_time = std::chrono::high_resolution_clock::now();  // 记录结束时间
//     auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
//     cout << "Throughput: " << num_records * 1000 / duration << " OPS" << endl;
//     cout << "Total Latency " << duration << " ms" << endl;
//     delete db;
// }

//测试创建二级索引后批量插入、以及删除索引后的查询
// TEST(TestNewDB, BulkPutFieldsAndDeleteIndexPerformance) {
//     // 创建 NewDB 实例
//     NewDB* db;
//     ASSERT_TRUE(OpenDB(testdbname, &db).ok());

//     db->CreateIndexOnField("address");

//     // 批量插入数据
//     std::vector<std::pair<std::string, FieldArray>> bulk_data;
//     const int num_records = 150000;

//     for (int i = 0; i < num_records; ++i) {
//         std::string key = "k_" + GenerateRandomString(10);
//         FieldArray fields = {
//             {"name", GenerateRandomString(10)},
//             {"address", GenerateRandomString(25)},
//             {"phone", GenerateRandomString(11)}
//         };
//         bulk_data.emplace_back(key, fields);

//         ASSERT_TRUE(db->Put_fields(WriteOptions(), key, fields).ok());
//     }

//     // 验证插入的数据和索引
//     for (const auto& [key, fields] : bulk_data) {
//         // 获取并验证字段数据
//         FieldArray retrieved_fields;
//         ASSERT_TRUE(db->Get_fields(ReadOptions(), Slice(key), &retrieved_fields).ok());
//         EXPECT_EQ(retrieved_fields.size(), fields.size());

//         // 验证插入的每个字段
//         for (size_t i = 0; i < fields.size(); ++i) {
//             EXPECT_EQ(fields[i].first, retrieved_fields[i].first);  // 字段名
//             EXPECT_EQ(fields[i].second, retrieved_fields[i].second); // 字段值
//         }

//         // 验证索引是否能正确找到对应的键
//         Field field_to_query{"address", fields[1].second}; // 使用 address 字段进行查询
//         std::vector<std::string> matching_keys = db->QueryByIndex(field_to_query);
//         EXPECT_FALSE(matching_keys.empty()); // 应该能找到对应的键
//         EXPECT_NE(std::find(matching_keys.begin(), matching_keys.end(), key), matching_keys.end());
//     }
//     // 测试插入吞吐量
//     auto start_time = std::chrono::high_resolution_clock::now();  // 记录开始时间
//     // 删除部分数据
//     const int num_updates = 100000;

//     for (int i = 0; i < num_updates; ++i) {
//         auto& [key, fields] = bulk_data[i];
//         ASSERT_TRUE(db->Delete(WriteOptions(), key));
//     }

//     // for (int i = 0; i < num_updates; ++i) {
//     //     Field query_field{"address", bulk_data[i].second[1].second};
//     //     std::vector<std::string> matching_keys = db->QueryByIndex(query_field);
//     //     EXPECT_TRUE(matching_keys.empty());
//     // }

//     // 删除索引
//     ASSERT_TRUE(db->DeleteIndex("address"));
//     auto end_time = std::chrono::high_resolution_clock::now();  // 记录结束时间
//     auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
    
//     // 计算吞吐量并输出
//     cout << "Throughput: " << num_updates * 1000 / duration << " OPS" << endl;
//     cout << "Total Latency " << duration << " ms" << endl;
//     // // 验证删除索引后无法再通过索引查询到数据
//     // for (const auto& [key, fields] : bulk_data) {
//     //     Field field_to_query{"address", fields[1].second}; // 使用 address 字段进行查询
//     //     std::vector<std::string> matching_keys = db->QueryByIndex(field_to_query);
//     //     EXPECT_TRUE(matching_keys.empty()); // 索引已被删除，应该找不到任何匹配的键
//     // }

//     delete db;
// }


// TEST(TestNewDB, UpdateFieldsAndQueryIndexPerformance) {
//     // 创建 NewDB 实例
//     NewDB* db;
//     ASSERT_TRUE(OpenDB(testdbname, &db).ok());

//     // 创建索引字段
//     ASSERT_TRUE(db->CreateIndexOnField("address"));

//     // 批量插入数据
//     const int num_records = 200000;
//     std::vector<std::pair<std::string, FieldArray>> initial_bulk_data;

//     for (int i = 0; i < num_records; ++i) {
//         std::string key = "k_" + GenerateRandomString(10);
//         FieldArray fields = {
//             {"name", GenerateRandomString(10)},
//             {"address", GenerateRandomString(25)},
//             {"phone", GenerateRandomString(11)}
//         };
//         initial_bulk_data.emplace_back(key, fields);

//         ASSERT_TRUE(db->Put_fields(WriteOptions(), key, fields).ok());
//     }

//     //验证初始数据的索引查询
//     for (const auto& [key, fields] : initial_bulk_data) {
//         Field query_field{"address", fields[1].second}; // 使用 address 字段进行查询
//         std::vector<std::string> matching_keys = db->QueryByIndex(query_field);
//         ASSERT_FALSE(matching_keys.empty()); // 应该能找到对应的键
//         EXPECT_NE(std::find(matching_keys.begin(), matching_keys.end(), key), matching_keys.end());
//     }

//     // 更新部分数据
//     const int num_updates = 100000;
//     std::vector<std::pair<std::string, FieldArray>> updated_bulk_data;
//     // 测试插入吞吐量
//     auto start_time = std::chrono::high_resolution_clock::now();  // 记录开始时间
//     for (int i = 0; i < num_updates; ++i) {
//         auto& [key, fields] = initial_bulk_data[i];
//         FieldArray updated_fields = {
//             {"name", fields[0].second},
//             {"address", GenerateRandomString(15)}, // 更新 address
//             {"phone", fields[2].second}
//         };
//         updated_bulk_data.emplace_back(key, updated_fields);

//         ASSERT_TRUE(db->Put_fields(WriteOptions(), key, updated_fields).ok());
//     }
//     auto end_time = std::chrono::high_resolution_clock::now();  // 记录结束时间
//     auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
    
//     // 计算吞吐量并输出
//     cout << "Throughput: " << num_updates * 1000 / duration << " OPS" << endl;
//     cout << "Total Latency " << duration << " ms" << endl;
//     // 验证更新后的数据和索引
//     for (const auto& [key, updated_fields] : updated_bulk_data) {
//         // 获取并验证字段数据
//         FieldArray retrieved_fields;
//         ASSERT_TRUE(db->Get_fields(ReadOptions(), Slice(key), &retrieved_fields).ok());
//         EXPECT_EQ(retrieved_fields.size(), updated_fields.size());

//         // 验证插入的每个字段
//         for (size_t i = 0; i < updated_fields.size(); ++i) {
//             EXPECT_EQ(updated_fields[i].first, retrieved_fields[i].first);  // 字段名
//             EXPECT_EQ(updated_fields[i].second, retrieved_fields[i].second); // 字段值
//         }

//         // 验证新的 address 字段值存在于索引中
//         Field query_field_new{"address", updated_fields[1].second};
//         std::vector<std::string> matching_keys_new = db->QueryByIndex(query_field_new);
//         ASSERT_FALSE(matching_keys_new.empty()); // 新地址应该能找到对应的键
//         EXPECT_NE(std::find(matching_keys_new.begin(), matching_keys_new.end(), key), matching_keys_new.end());
//     }
//     for (int i = 0; i < num_updates; ++i) {
//         // 验证旧的 address 字段值不再存在于索引中
//         Field query_field_old{"address", initial_bulk_data[i].second[1].second};
//         std::vector<std::string> matching_keys_old = db->QueryByIndex(query_field_old);
//         EXPECT_TRUE(matching_keys_old.empty()); // 旧地址不应该再找到对应的键
//     }

//     delete db;
// }


int main(int argc, char** argv) {
    // 设置全局随机种子
    SetGlobalSeed(static_cast<unsigned>(time(nullptr)));
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}