Types

static StorageConfig Memory();
static StorageConfig Disk(std::optional<std::filesystem::path> path,
                          CachePolicy cache_policy = {});
static StorageConfig S3(std::string bucket, S3Options opts = {});

#include "cyborgdb_core/client.hpp"

// Ephemeral in-memory store
cyborg::StorageConfig mem = cyborg::StorageConfig::Memory();

// Local disk store with vector caching
cyborg::CachePolicy cache;
cache.vectors = true;
cyborg::StorageConfig disk = cyborg::StorageConfig::Disk("/tmp/cyborgdb", cache);

// S3 store with explicit credentials
cyborg::S3Options opts;
opts.region = "us-east-1";
opts.credentials = cyborg::S3Credentials{"ACCESS_KEY", "SECRET_KEY"};
cyborg::StorageConfig s3 = cyborg::StorageConfig::S3("my-bucket", opts);

struct CachePolicy {
    bool vectors = false;   // Cache vector data in memory
    bool metadata = false;  // Cache metadata in memory
    bool ids = false;       // Cache item IDs in memory
};

struct S3Options {
    std::string prefix = "";                       // Key prefix within the bucket
    std::optional<std::string> region;             // AWS region
    std::optional<std::string> endpoint;           // Custom endpoint (MinIO/Ceph/R2)
    std::optional<S3Credentials> credentials;      // Explicit credentials
};

struct S3Credentials {
    std::string access_key;
    std::string secret_key;
    std::optional<std::string> session_token;
};

enum GPUConfig : uint8_t {
    kNone = 0,                        // No GPU usage
    kUpsert = 1 << 0,                 // Use GPU for upsert operations
    kTrain = 1 << 1,                  // Use GPU for training operations
    kQuery = 1 << 2,                  // Use GPU for query operations
    kAll = kUpsert | kTrain | kQuery  // Use GPU for all operations
};

// Enable GPU for all operations
cyborg::GPUConfig config1 = cyborg::kAll;

// Enable GPU only for training and query
cyborg::GPUConfig config2 = cyborg::kTrain | cyborg::kQuery;

// Enable GPU only for upsert
cyborg::GPUConfig config3 = cyborg::kUpsert;

// Disable GPU completely
cyborg::GPUConfig config4 = cyborg::kNone;

DeviceConfig(const int cpu_threads = 0, const GPUConfig gpu_config = kNone);

// 4 CPU threads, GPU enabled for training and query
cyborg::DeviceConfig device_config(4, cyborg::kTrain | cyborg::kQuery);
int threads = device_config.cpu_threads();           // Returns 4
cyborg::GPUConfig gpu = device_config.gpu_config();  // Returns kTrain | kQuery

enum class DistanceMetric {
    Cosine,
    Euclidean,
    SquaredEuclidean};

IndexDiskIVF(size_t dimension = 0,
             std::optional<std::string> embedding_model = "",
             StoragePrecision storage_precision = StoragePrecision::Float32);

// Default configuration (dimension auto-detected, float32 rerank vectors)
cyborg::IndexDiskIVF config1;

// Explicit dimension
cyborg::IndexDiskIVF config2(1024);

// Explicit dimension with float16 storage precision (smaller on-disk footprint)
cyborg::IndexDiskIVF config3(1024, "", cyborg::StoragePrecision::Float16);

enum class StoragePrecision {
    Float32,   // Full precision (default)
    Float16    // Half precision — halves disk footprint, slight precision loss
};

enum class TrainingState : uint8_t {
    Untrained = 0,  // Index has not been trained
    Training  = 1,  // A (re)train rebuild is in progress
    Trained   = 2   // Training is complete
};

enum IndexType {
    DISK_IVF
};

Array2D(size_t rows, size_t cols, const T& initial_value = T());
Array2D(std::vector<T>&& data, size_t cols);
Array2D(const std::vector<T>& data, size_t cols);
Array2D(std::initializer_list<std::initializer_list<T>> init_list);
Array2D(Array2D&& other) noexcept;
Array2D();

// Converting a vector to an array
std::vector<uint8_t> vec = {0, 1, 2, 3, 4, 5, 6, 7};
cyborg::Array2D<uint8_t> arr(vec, 2);
// arr is now a 2D array of 4 rows and 2 columns, with the contents from vec

// Creating a 2D array with 3 rows and 2 columns, initialized to zero
cyborg::Array2D<int> array(3, 2, 0);

// Access and modify elements
array(0, 0) = 1;
array(0, 1) = 2;

// Printing the array
for (size_t i = 0; i < array.rows(); ++i) {
    for (size_t j = 0; j < array.cols(); ++j) {
        std::cout << array(i, j) << " ";
    }
    std::cout << std::endl;
}

TrainingConfig(std::optional<size_t> n_lists = std::nullopt,
               std::optional<size_t> batch_size = std::nullopt,
               std::optional<size_t> max_iters = std::nullopt,
               std::optional<double> tolerance = std::nullopt,
               std::optional<size_t> max_memory = std::nullopt);

size_t batch_size;   // Batch size (default: 0, auto)
size_t max_iters;    // Maximum iterations (default: 100)
double tolerance;    // Convergence tolerance (default: 1e-6)
size_t max_memory;   // Maximum memory in MB (default: 0, no limit)
size_t n_lists;      // Number of inverted lists (default: 0, auto-determine)

explicit QueryParams(size_t top_k = 100,
                     size_t n_probes = 0,
                     std::string filters = "",
                     std::vector<ResultFields> include = {},
                     bool greedy = false,
                     size_t rerank_mult = 50);   // kDefaultRerankMult = 50

struct ResultView {
    const std::vector<std::string>& ids;
    const std::vector<float>& distances;
    const std::vector<std::string>& metadata;
    const uint32_t& num_results;
};

// Access results for each query
for (size_t i = 0; i < results.num_queries(); ++i) {
    auto view = results[i];
    for (uint32_t j = 0; j < view.num_results; ++j) {
        std::cout << "ID: " << view.ids[j]
                  << ", Distance: " << view.distances[j] << std::endl;
    }
}

// Access all IDs and distances directly
const auto& all_ids = results.ids();
const auto& all_distances = results.distances();

// Get actual result counts per query
auto counts = results.num_results();

// Create empty results
auto empty = QueryResults::Empty(num_queries);

using ItemID = std::string;

struct Item {
    const std::string id;                   // Item ID
    const std::vector<float> vector;        // Vector embedding
    const std::vector<uint8_t> contents;    // Decrypted contents
    const std::string metadata;             // Metadata (JSON string)
};

enum class ResultFields {
    kDistance,    // Include distance scores in query results
    kMetadata     // Include metadata in query results
};

enum class ItemFields {
    kVector,       // Include vector in returned items
    kMetadata,     // Include metadata in returned items
    kContents      // Include content data in returned items
};

// Root access: a bare 32-byte index KEK converts implicitly.
std::array<uint8_t, 32> index_key = {/* ... */};
index->Query(q, cyborg::QueryParams{}, index_key);

// RBAC user access: pass the user's 32-byte KEK and 16-byte user ID.
std::array<uint8_t, 32> user_kek = {/* ... */};
std::array<uint8_t, 16> user_id  = {/* ... */};
index->Query(q, cyborg::QueryParams{}, cyborg::KeyContext{user_kek, user_id});

struct KMSBlob {
    std::string kms_name;             // Logical KMS name
    std::string provider;             // "aws" | "aws-kms" | "none"
    std::string key_id;               // KMS key identifier
    std::string region;               // KMS region
    std::vector<uint8_t> wrapped_kek; // Wrapped KEK bytes
    uint32_t version = 0;             // Envelope version
    int64_t created_at = 0;           // Unix epoch seconds
};