use radixtree::{Node, NodeRef};

#[test]
fn test_node_serialization() {
    // Create a node with some data
    let node = Node {
        key_segment: "test".to_string(),
        value: b"test_value".to_vec(),
        children: vec![
            NodeRef {
                key_part: "child1".to_string(),
                node_id: 1,
            },
            NodeRef {
                key_part: "child2".to_string(),
                node_id: 2,
            },
        ],
        is_leaf: true,
    };

    // Serialize the node
    let serialized = node.serialize();
    
    // Deserialize the node
    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
    
    // Verify the deserialized node matches the original
    assert_eq!(deserialized.key_segment, node.key_segment);
    assert_eq!(deserialized.value, node.value);
    assert_eq!(deserialized.is_leaf, node.is_leaf);
    assert_eq!(deserialized.children.len(), node.children.len());
    
    for (i, child) in node.children.iter().enumerate() {
        assert_eq!(deserialized.children[i].key_part, child.key_part);
        assert_eq!(deserialized.children[i].node_id, child.node_id);
    }
}

#[test]
fn test_empty_node_serialization() {
    // Create an empty node
    let node = Node {
        key_segment: "".to_string(),
        value: vec![],
        children: vec![],
        is_leaf: false,
    };

    // Serialize the node
    let serialized = node.serialize();
    
    // Deserialize the node
    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
    
    // Verify the deserialized node matches the original
    assert_eq!(deserialized.key_segment, node.key_segment);
    assert_eq!(deserialized.value, node.value);
    assert_eq!(deserialized.is_leaf, node.is_leaf);
    assert_eq!(deserialized.children.len(), node.children.len());
}

#[test]
fn test_node_with_many_children() {
    // Create a node with many children
    let mut children = Vec::new();
    for i in 0..100 {
        children.push(NodeRef {
            key_part: format!("child{}", i),
            node_id: i as u32,
        });
    }
    
    let node = Node {
        key_segment: "parent".to_string(),
        value: b"parent_value".to_vec(),
        children,
        is_leaf: true,
    };

    // Serialize the node
    let serialized = node.serialize();
    
    // Deserialize the node
    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
    
    // Verify the deserialized node matches the original
    assert_eq!(deserialized.key_segment, node.key_segment);
    assert_eq!(deserialized.value, node.value);
    assert_eq!(deserialized.is_leaf, node.is_leaf);
    assert_eq!(deserialized.children.len(), node.children.len());
    
    for (i, child) in node.children.iter().enumerate() {
        assert_eq!(deserialized.children[i].key_part, child.key_part);
        assert_eq!(deserialized.children[i].node_id, child.node_id);
    }
}

#[test]
fn test_node_with_large_value() {
    // Create a node with a large value
    let large_value = vec![0u8; 4096]; // 4KB value
    
    let node = Node {
        key_segment: "large_value".to_string(),
        value: large_value.clone(),
        children: vec![],
        is_leaf: true,
    };

    // Serialize the node
    let serialized = node.serialize();
    
    // Deserialize the node
    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
    
    // Verify the deserialized node matches the original
    assert_eq!(deserialized.key_segment, node.key_segment);
    assert_eq!(deserialized.value, node.value);
    assert_eq!(deserialized.is_leaf, node.is_leaf);
    assert_eq!(deserialized.children.len(), node.children.len());
}

#[test]
fn test_version_compatibility() {
    // This test ensures that the serialization format is compatible with version 1
    
    // Create a node
    let node = Node {
        key_segment: "test".to_string(),
        value: b"test_value".to_vec(),
        children: vec![
            NodeRef {
                key_part: "child".to_string(),
                node_id: 1,
            },
        ],
        is_leaf: true,
    };

    // Serialize the node
    let serialized = node.serialize();
    
    // Verify the first byte is the version byte (1)
    assert_eq!(serialized[0], 1);
    
    // Deserialize the node
    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
    
    // Verify the deserialized node matches the original
    assert_eq!(deserialized.key_segment, node.key_segment);
    assert_eq!(deserialized.value, node.value);
    assert_eq!(deserialized.is_leaf, node.is_leaf);
    assert_eq!(deserialized.children.len(), node.children.len());
}

#[test]
fn test_invalid_serialization() {
    // Test with empty data
    let result = Node::deserialize(&[]);
    assert!(result.is_err());
    
    // Test with invalid version
    let result = Node::deserialize(&[2, 0, 0, 0, 0]);
    assert!(result.is_err());
    
    // Test with truncated data
    let node = Node {
        key_segment: "test".to_string(),
        value: b"test_value".to_vec(),
        children: vec![],
        is_leaf: true,
    };
    
    let serialized = node.serialize();
    let truncated = &serialized[0..serialized.len() / 2];
    
    let result = Node::deserialize(truncated);
    assert!(result.is_err());
}