tcvectordb 0.1.9

use tcvectordb::{
    enums::{FieldType, IndexType, MetricType, ReadConsistency},
    index::HNSWParams,
    FilterIndex, Index, Result, VectorDBClient, VectorIndex,
};

#[tokio::main]
async fn main() -> Result<()> {
    let url = std::env::var("VECTORDB_URL").expect("VECTORDB_URL not set");
    let username = std::env::var("VECTORDB_USERNAME").expect("VECTORDB_USERNAME not set");
    let api_key = std::env::var("VECTORDB_API_KEY").expect("VECTORDB_API_KEY not set");

    let client = VectorDBClient::new(
        &url,
        &username,
        &api_key,
        ReadConsistency::EventualConsistency,
        30,
    )?;
    println!("✅ Client created successfully");

    // 创建测试数据库
    let db_name = "test_methods_db";
    let db = client.create_database_if_not_exists(db_name).await?;
    println!("✅ Database '{}' ready", db_name);

    // 创建一个测试集合
    let collection_name = "test_methods_collection";

    // 创建索引
    let mut index = Index::new();
    index.add_vector_index(VectorIndex::new(
        "vector",
        3,
        IndexType::HNSW,
        MetricType::COSINE,
        Some(tcvectordb::index::IndexParams::HNSW(HNSWParams::new(
            16, 200,
        ))),
    ))?;
    index.add_filter_index(FilterIndex::new(
        "id",
        FieldType::String,
        IndexType::PRIMARY_KEY,
    ))?;

    println!("\n🔧 Creating test collection...");
    let _collection = db
        .create_collection(
            collection_name,
            3,
            0,
            Some("Test methods collection".to_string()),
            Some(index),
            None,
            None,
        )
        .await?;
    println!("✅ Collection '{}' created", collection_name);

    // 测试 describe_collection
    println!("\n📋 Testing describe_collection...");
    match db.describe_collection(collection_name).await {
        Ok(_collection) => {
            println!("✅ describe_collection successful");
        }
        Err(e) => {
            println!("❌ describe_collection failed: {}", e);
        }
    }

    // 测试 truncate_collection
    println!("\n🗑️ Testing truncate_collection...");
    match db.truncate_collection(collection_name).await {
        Ok(_result) => {
            println!("✅ truncate_collection successful");
        }
        Err(e) => {
            println!("❌ truncate_collection failed: {}", e);
        }
    }

    // 测试 set_alias
    println!("\n🏷️ Testing set_alias...");
    let alias_name = "test_alias";
    match db.set_alias(collection_name, alias_name).await {
        Ok(_result) => {
            println!("✅ set_alias successful");
        }
        Err(e) => {
            println!("❌ set_alias failed: {}", e);
        }
    }

    // 测试 delete_alias
    println!("\n🗑️ Testing delete_alias...");
    match db.delete_alias(alias_name).await {
        Ok(_result) => {
            println!("✅ delete_alias successful");
        }
        Err(e) => {
            println!("❌ delete_alias failed: {}", e);
        }
    }

    // 清理
    println!("\n🧹 Cleaning up...");
    match db.drop_collection(collection_name).await {
        Ok(_) => {
            println!("✅ Collection '{}' dropped successfully", collection_name);
        }
        Err(e) => {
            println!("❌ Failed to drop collection: {}", e);
        }
    }

    // 清理数据库
    match client.drop_database(db_name).await {
        Ok(_) => {
            println!("✅ Database '{}' dropped successfully", db_name);
        }
        Err(e) => {
            println!("❌ Failed to drop database: {}", e);
        }
    }

    println!("\n🎉 Database methods test completed!");
    Ok(())
}