use radixtree::RadixTree;
use std::path::PathBuf;
use tempfile::tempdir;

#[test]
fn test_basic_operations() -> Result<(), radixtree::Error> {
    // Create a temporary directory for the test
    let temp_dir = tempdir().expect("Failed to create temp directory");
    let db_path = temp_dir.path().to_str().unwrap();
    
    // Create a new radix tree
    let mut tree = RadixTree::new(db_path, true)?;
    
    // Test setting and getting values
    let key = "test_key";
    let value = b"test_value".to_vec();
    tree.set(key, value.clone())?;
    
    let retrieved_value = tree.get(key)?;
    assert_eq!(retrieved_value, value);
    
    // Test updating a value
    let new_value = b"updated_value".to_vec();
    tree.update(key, new_value.clone())?;
    
    let updated_value = tree.get(key)?;
    assert_eq!(updated_value, new_value);
    
    // Test deleting a value
    tree.delete(key)?;
    
    // Trying to get a deleted key should return an error
    let result = tree.get(key);
    assert!(result.is_err());
    
    Ok(())
}

#[test]
fn test_empty_key() -> Result<(), radixtree::Error> {
    // Create a temporary directory for the test
    let temp_dir = tempdir().expect("Failed to create temp directory");
    let db_path = temp_dir.path().to_str().unwrap();
    
    // Create a new radix tree
    let mut tree = RadixTree::new(db_path, true)?;
    
    // Test setting and getting empty key
    let key = "";
    let value = b"value_for_empty_key".to_vec();
    tree.set(key, value.clone())?;
    
    let retrieved_value = tree.get(key)?;
    assert_eq!(retrieved_value, value);
    
    // Test deleting empty key
    tree.delete(key)?;
    
    // Trying to get a deleted key should return an error
    let result = tree.get(key);
    assert!(result.is_err());
    
    Ok(())
}

#[test]
fn test_multiple_keys() -> Result<(), radixtree::Error> {
    // Create a temporary directory for the test
    let temp_dir = tempdir().expect("Failed to create temp directory");
    let db_path = temp_dir.path().to_str().unwrap();
    
    // Create a new radix tree
    let mut tree = RadixTree::new(db_path, true)?;
    
    // Insert multiple keys
    let test_data = [
        ("key1", b"value1".to_vec()),
        ("key2", b"value2".to_vec()),
        ("key3", b"value3".to_vec()),
    ];
    
    for (key, value) in &test_data {
        tree.set(key, value.clone())?;
    }
    
    // Verify all keys can be retrieved
    for (key, expected_value) in &test_data {
        let retrieved_value = tree.get(key)?;
        assert_eq!(&retrieved_value, expected_value);
    }
    
    Ok(())
}

#[test]
fn test_shared_prefixes() -> Result<(), radixtree::Error> {
    // Create a temporary directory for the test
    let temp_dir = tempdir().expect("Failed to create temp directory");
    let db_path = temp_dir.path().to_str().unwrap();
    
    // Create a new radix tree
    let mut tree = RadixTree::new(db_path, true)?;
    
    // Insert keys with shared prefixes
    let test_data = [
        ("test", b"value_test".to_vec()),
        ("testing", b"value_testing".to_vec()),
        ("tested", b"value_tested".to_vec()),
    ];
    
    for (key, value) in &test_data {
        tree.set(key, value.clone())?;
    }
    
    // Verify all keys can be retrieved
    for (key, expected_value) in &test_data {
        let retrieved_value = tree.get(key)?;
        assert_eq!(&retrieved_value, expected_value);
    }
    
    Ok(())
}

#[test]
fn test_persistence() -> Result<(), radixtree::Error> {
    // Create a temporary directory for the test
    let temp_dir = tempdir().expect("Failed to create temp directory");
    let db_path = temp_dir.path().to_str().unwrap();
    
    // Create a new radix tree and add some data
    {
        let mut tree = RadixTree::new(db_path, true)?;
        tree.set("persistent_key", b"persistent_value".to_vec())?;
    } // Tree is dropped here
    
    // Create a new tree instance with the same path
    {
        let mut tree = RadixTree::new(db_path, false)?;
        let value = tree.get("persistent_key")?;
        assert_eq!(value, b"persistent_value".to_vec());
    }
    
    Ok(())
}