use herodb::rpc::{BackendType, DatabaseConfig};
use herodb::admin_meta;
use herodb::options::BackendType as OptionsBackendType;

#[tokio::test]
async fn test_rpc_server_basic() {
    // This test would require starting the RPC server in a separate thread
    // For now, we'll just test that the types compile correctly

    // Test serialization of types
    let backend = BackendType::Redb;
    let config = DatabaseConfig {
        name: Some("test_db".to_string()),
        storage_path: Some("/tmp/test".to_string()),
        max_size: Some(1024 * 1024),
        redis_version: Some("7.0".to_string()),
    };

    let backend_json = serde_json::to_string(&backend).unwrap();
    let config_json = serde_json::to_string(&config).unwrap();

    assert_eq!(backend_json, "\"Redb\"");
    assert!(config_json.contains("test_db"));
}

#[tokio::test]
async fn test_database_config_serialization() {
    let config = DatabaseConfig {
        name: Some("my_db".to_string()),
        storage_path: None,
        max_size: Some(1000000),
        redis_version: Some("7.0".to_string()),
    };

    let json = serde_json::to_value(&config).unwrap();
    assert_eq!(json["name"], "my_db");
    assert_eq!(json["max_size"], 1000000);
    assert_eq!(json["redis_version"], "7.0");
}

#[tokio::test]
async fn test_backend_type_serialization() {
    // Test that both Redb and Sled backends serialize correctly
    let redb_backend = BackendType::Redb;
    let sled_backend = BackendType::Sled;

    let redb_json = serde_json::to_string(&redb_backend).unwrap();
    let sled_json = serde_json::to_string(&sled_backend).unwrap();

    assert_eq!(redb_json, "\"Redb\"");
    assert_eq!(sled_json, "\"Sled\"");

    // Test deserialization
    let redb_deserialized: BackendType = serde_json::from_str(&redb_json).unwrap();
    let sled_deserialized: BackendType = serde_json::from_str(&sled_json).unwrap();

    assert!(matches!(redb_deserialized, BackendType::Redb));
    assert!(matches!(sled_deserialized, BackendType::Sled));
}

#[tokio::test]
async fn test_database_name_persistence() {
    let base_dir = "/tmp/test_db_name_persistence";
    let admin_secret = "test-admin-secret";
    let backend = OptionsBackendType::Redb;
    let db_id = 1;
    let test_name = "test-database-name";

    // Clean up any existing test data
    let _ = std::fs::remove_dir_all(base_dir);

    // Set the database name
    admin_meta::set_database_name(base_dir, backend.clone(), admin_secret, db_id, test_name)
        .expect("Failed to set database name");

    // Retrieve the database name
    let retrieved_name = admin_meta::get_database_name(base_dir, backend, admin_secret, db_id)
        .expect("Failed to get database name");

    // Verify the name matches
    assert_eq!(retrieved_name, Some(test_name.to_string()));

    // Clean up
    let _ = std::fs::remove_dir_all(base_dir);
}