lcpfs 2026.1.102

// Copyright 2025 LunaOS Contributors
// SPDX-License-Identifier: Apache-2.0

//! Vector search type definitions.
//!
//! This module provides core data structures for vector embeddings,
//! HNSW graph nodes, and search results used throughout the vector
//! search subsystem.

use alloc::format;
use alloc::string::String;
use alloc::vec;
use alloc::vec::Vec;

// ═══════════════════════════════════════════════════════════════════════════════
// VECTOR EMBEDDING
// ═══════════════════════════════════════════════════════════════════════════════

/// Quantization type for vector embeddings.
///
/// Different quantization levels trade off between precision and storage size:
/// - `F32`: Full precision, 4 bytes per dimension
/// - `F16`: Half precision, 2 bytes per dimension
/// - `Int8`: 8-bit integers, 1 byte per dimension (requires scale factor)
/// - `Binary`: 1-bit, 1/8 byte per dimension (for Hamming distance)
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
#[derive(Default)]
pub enum QuantizationType {
    /// 32-bit floating point (full precision)
    #[default]
    F32 = 0,
    /// 16-bit floating point (half precision)
    F16 = 1,
    /// 8-bit signed integer (requires scale/offset)
    Int8 = 2,
    /// Binary quantization (1-bit per dimension)
    Binary = 3,
}

impl From<u8> for QuantizationType {
    fn from(value: u8) -> Self {
        match value {
            0 => Self::F32,
            1 => Self::F16,
            2 => Self::Int8,
            3 => Self::Binary,
            _ => Self::F32,
        }
    }
}

/// Vector embedding header stored on disk.
///
/// This structure is followed by the actual embedding data, whose format
/// depends on the `quantization` field. The total size is:
/// - F32: header_size + dimensions * 4 bytes
/// - F16: header_size + dimensions * 2 bytes
/// - Int8: header_size + dimensions bytes + 8 bytes (scale + offset)
/// - Binary: header_size + ceil(dimensions / 8) bytes
///
/// # On-Disk Layout
///
/// ```text
/// +------------------+
/// | object_id (8)    |
/// | model_id (4)     |
/// | dimensions (4)   |
/// | quantization (1) |
/// | reserved (7)     |
/// +------------------+
/// | embedding data   |
/// | (variable)       |
/// +------------------+
/// ```
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct VectorEmbeddingHeader {
    /// Object ID this embedding belongs to.
    pub object_id: u64,
    /// Embedding model identifier hash (e.g., hash of "clip-vit-b32").
    pub model_id: u32,
    /// Number of dimensions in the embedding vector.
    pub dimensions: u32,
    /// Quantization type (see [`QuantizationType`]).
    pub quantization: u8,
    /// Reserved for future use.
    pub reserved: [u8; 7],
}

impl VectorEmbeddingHeader {
    /// Size of the header in bytes.
    pub const SIZE: usize = 24;

    /// Create a new embedding header.
    pub fn new(
        object_id: u64,
        model_id: u32,
        dimensions: u32,
        quantization: QuantizationType,
    ) -> Self {
        Self {
            object_id,
            model_id,
            dimensions,
            quantization: quantization as u8,
            reserved: [0u8; 7],
        }
    }

    /// Get the quantization type.
    pub fn quantization_type(&self) -> QuantizationType {
        QuantizationType::from(self.quantization)
    }

    /// Calculate the size of the embedding data in bytes (excluding header).
    pub fn data_size(&self) -> usize {
        match self.quantization_type() {
            QuantizationType::F32 => self.dimensions as usize * 4,
            QuantizationType::F16 => self.dimensions as usize * 2,
            QuantizationType::Int8 => self.dimensions as usize + 8, // +8 for scale/offset
            QuantizationType::Binary => (self.dimensions as usize).div_ceil(8),
        }
    }

    /// Calculate the total size including header and data.
    pub fn total_size(&self) -> usize {
        Self::SIZE + self.data_size()
    }

    /// Serialize to bytes.
    pub fn to_bytes(&self) -> [u8; Self::SIZE] {
        let mut buf = [0u8; Self::SIZE];
        buf[0..8].copy_from_slice(&self.object_id.to_le_bytes());
        buf[8..12].copy_from_slice(&self.model_id.to_le_bytes());
        buf[12..16].copy_from_slice(&self.dimensions.to_le_bytes());
        buf[16] = self.quantization;
        // reserved bytes are already zero
        buf
    }

    /// Deserialize from bytes.
    pub fn from_bytes(buf: &[u8; Self::SIZE]) -> Self {
        Self {
            object_id: u64::from_le_bytes([
                buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
            ]),
            model_id: u32::from_le_bytes([buf[8], buf[9], buf[10], buf[11]]),
            dimensions: u32::from_le_bytes([buf[12], buf[13], buf[14], buf[15]]),
            quantization: buf[16],
            reserved: [
                buf[17], buf[18], buf[19], buf[20], buf[21], buf[22], buf[23],
            ],
        }
    }
}

/// Complete vector embedding with data.
#[derive(Debug, Clone)]
pub struct VectorEmbedding {
    /// Header containing metadata.
    pub header: VectorEmbeddingHeader,
    /// The embedding vector data (always stored as f32 in memory).
    pub data: Vec<f32>,
}

impl VectorEmbedding {
    /// Create a new vector embedding.
    pub fn new(object_id: u64, model_id: u32, data: Vec<f32>) -> Self {
        let dimensions = data.len() as u32;
        Self {
            header: VectorEmbeddingHeader::new(
                object_id,
                model_id,
                dimensions,
                QuantizationType::F32,
            ),
            data,
        }
    }

    /// Create with specific quantization type (data is still f32, quantization is for storage).
    pub fn with_quantization(
        object_id: u64,
        model_id: u32,
        data: Vec<f32>,
        quantization: QuantizationType,
    ) -> Self {
        let dimensions = data.len() as u32;
        Self {
            header: VectorEmbeddingHeader::new(object_id, model_id, dimensions, quantization),
            data,
        }
    }

    /// Get the object ID.
    pub fn object_id(&self) -> u64 {
        self.header.object_id
    }

    /// Get the embedding dimensions.
    pub fn dimensions(&self) -> usize {
        self.header.dimensions as usize
    }

    /// Get a reference to the embedding data.
    pub fn as_slice(&self) -> &[f32] {
        &self.data
    }

    /// Compute the L2 norm of the embedding.
    pub fn l2_norm(&self) -> f32 {
        let sum: f32 = self.data.iter().map(|x| x * x).sum();
        libm::sqrtf(sum)
    }

    /// Normalize the embedding to unit length.
    pub fn normalize(&mut self) {
        let norm = self.l2_norm();
        if norm > 1e-10 {
            for x in &mut self.data {
                *x /= norm;
            }
        }
    }

    /// Create a normalized copy.
    pub fn normalized(&self) -> Self {
        let mut copy = self.clone();
        copy.normalize();
        copy
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// HNSW NODE
// ═══════════════════════════════════════════════════════════════════════════════

/// Maximum neighbors per layer in HNSW graph.
pub const HNSW_MAX_NEIGHBORS: usize = 32;

/// HNSW graph node representing connections at a single layer.
///
/// Each node stores its connections to neighboring nodes at one layer
/// of the HNSW graph. Nodes at higher layers have fewer neighbors
/// (typically M for layer 0, M/2 for higher layers).
///
/// # On-Disk Layout
///
/// ```text
/// +--------------------+
/// | object_id (8)      |
/// | layer (1)          |
/// | neighbor_count (1) |
/// | reserved (6)       |
/// | neighbors (32 * 8) |
/// +--------------------+
/// Total: 272 bytes
/// ```
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct HnswNode {
    /// Object ID this node represents.
    pub object_id: u64,
    /// Layer in the HNSW graph (0 = bottom/base layer).
    pub layer: u8,
    /// Number of valid neighbors (0 to HNSW_MAX_NEIGHBORS).
    pub neighbor_count: u8,
    /// Reserved for future use.
    pub reserved: [u8; 6],
    /// Neighbor object IDs (only first `neighbor_count` are valid).
    pub neighbors: [u64; HNSW_MAX_NEIGHBORS],
}

impl HnswNode {
    /// Size of an HNSW node in bytes.
    pub const SIZE: usize = 8 + 1 + 1 + 6 + (HNSW_MAX_NEIGHBORS * 8);

    /// Create a new empty HNSW node.
    pub fn new(object_id: u64, layer: u8) -> Self {
        Self {
            object_id,
            layer,
            neighbor_count: 0,
            reserved: [0u8; 6],
            neighbors: [0u64; HNSW_MAX_NEIGHBORS],
        }
    }

    /// Add a neighbor to this node.
    ///
    /// Returns `true` if the neighbor was added, `false` if the node is full.
    pub fn add_neighbor(&mut self, neighbor_id: u64) -> bool {
        if (self.neighbor_count as usize) < HNSW_MAX_NEIGHBORS {
            self.neighbors[self.neighbor_count as usize] = neighbor_id;
            self.neighbor_count += 1;
            true
        } else {
            false
        }
    }

    /// Remove a neighbor from this node.
    ///
    /// Returns `true` if the neighbor was found and removed.
    pub fn remove_neighbor(&mut self, neighbor_id: u64) -> bool {
        for i in 0..self.neighbor_count as usize {
            if self.neighbors[i] == neighbor_id {
                // Shift remaining neighbors down
                for j in i..self.neighbor_count as usize - 1 {
                    self.neighbors[j] = self.neighbors[j + 1];
                }
                self.neighbor_count -= 1;
                self.neighbors[self.neighbor_count as usize] = 0;
                return true;
            }
        }
        false
    }

    /// Check if this node has a specific neighbor.
    pub fn has_neighbor(&self, neighbor_id: u64) -> bool {
        for i in 0..self.neighbor_count as usize {
            if self.neighbors[i] == neighbor_id {
                return true;
            }
        }
        false
    }

    /// Get the valid neighbors as a slice.
    pub fn get_neighbors(&self) -> &[u64] {
        &self.neighbors[..self.neighbor_count as usize]
    }

    /// Set neighbors from a slice (overwrites existing).
    pub fn set_neighbors(&mut self, neighbors: &[u64]) {
        let count = neighbors.len().min(HNSW_MAX_NEIGHBORS);
        self.neighbors[..count].copy_from_slice(&neighbors[..count]);
        self.neighbor_count = count as u8;
    }

    /// Serialize to bytes.
    pub fn to_bytes(&self) -> [u8; Self::SIZE] {
        let mut buf = [0u8; Self::SIZE];
        buf[0..8].copy_from_slice(&self.object_id.to_le_bytes());
        buf[8] = self.layer;
        buf[9] = self.neighbor_count;
        // reserved bytes are already zero
        for (i, &neighbor) in self.neighbors.iter().enumerate() {
            let offset = 16 + i * 8;
            buf[offset..offset + 8].copy_from_slice(&neighbor.to_le_bytes());
        }
        buf
    }

    /// Deserialize from bytes.
    pub fn from_bytes(buf: &[u8; Self::SIZE]) -> Self {
        let object_id = u64::from_le_bytes([
            buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
        ]);
        let layer = buf[8];
        let neighbor_count = buf[9];
        let reserved = [buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]];

        let mut neighbors = [0u64; HNSW_MAX_NEIGHBORS];
        for (i, neighbor) in neighbors.iter_mut().enumerate() {
            let offset = 16 + i * 8;
            *neighbor = u64::from_le_bytes([
                buf[offset],
                buf[offset + 1],
                buf[offset + 2],
                buf[offset + 3],
                buf[offset + 4],
                buf[offset + 5],
                buf[offset + 6],
                buf[offset + 7],
            ]);
        }

        Self {
            object_id,
            layer,
            neighbor_count,
            reserved,
            neighbors,
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// SEARCH RESULTS
// ═══════════════════════════════════════════════════════════════════════════════

/// Result from a vector similarity search.
#[derive(Debug, Clone)]
pub struct VectorSearchResult {
    /// Object ID of the matching file/object.
    pub object_id: u64,
    /// File path (if available).
    pub path: Option<String>,
    /// Similarity score (higher is more similar, 0.0-1.0 for cosine).
    pub score: f32,
    /// Raw distance from query vector (interpretation depends on metric).
    pub distance: f32,
}

impl VectorSearchResult {
    /// Create a new search result.
    pub fn new(object_id: u64, score: f32, distance: f32) -> Self {
        Self {
            object_id,
            path: None,
            score,
            distance,
        }
    }

    /// Create with path.
    pub fn with_path(object_id: u64, path: String, score: f32, distance: f32) -> Self {
        Self {
            object_id,
            path: Some(path),
            score,
            distance,
        }
    }
}

impl PartialEq for VectorSearchResult {
    fn eq(&self, other: &Self) -> bool {
        self.object_id == other.object_id
    }
}

impl Eq for VectorSearchResult {}

impl PartialOrd for VectorSearchResult {
    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for VectorSearchResult {
    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
        // Higher score = better, so reverse comparison for max-heap behavior
        other
            .score
            .partial_cmp(&self.score)
            .unwrap_or(core::cmp::Ordering::Equal)
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// DISTANCE METRICS
// ═══════════════════════════════════════════════════════════════════════════════

/// Distance metric for vector similarity.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum DistanceMetric {
    /// Cosine similarity (1 - cosine distance).
    #[default]
    Cosine,
    /// Euclidean (L2) distance.
    Euclidean,
    /// Dot product (inner product).
    DotProduct,
    /// Manhattan (L1) distance.
    Manhattan,
    /// Hamming distance (for binary vectors).
    Hamming,
}

impl DistanceMetric {
    /// Convert a string to a distance metric.
    pub fn from_str(s: &str) -> Option<Self> {
        match s.to_lowercase().as_str() {
            "cosine" | "cos" => Some(Self::Cosine),
            "euclidean" | "l2" | "euclid" => Some(Self::Euclidean),
            "dot" | "dotproduct" | "inner" => Some(Self::DotProduct),
            "manhattan" | "l1" => Some(Self::Manhattan),
            "hamming" => Some(Self::Hamming),
            _ => None,
        }
    }

    /// Get the name of this metric.
    pub fn name(&self) -> &'static str {
        match self {
            Self::Cosine => "cosine",
            Self::Euclidean => "euclidean",
            Self::DotProduct => "dot",
            Self::Manhattan => "manhattan",
            Self::Hamming => "hamming",
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// INDEX TYPES
// ═══════════════════════════════════════════════════════════════════════════════

/// Type of vector index.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum IndexType {
    /// Hierarchical Navigable Small World graph (default).
    #[default]
    Hnsw,
    /// Inverted File index (for very large datasets).
    Ivf,
    /// Flat/brute-force (exact search, no approximation).
    Flat,
}

impl IndexType {
    /// Convert from string.
    pub fn from_str(s: &str) -> Option<Self> {
        match s.to_lowercase().as_str() {
            "hnsw" => Some(Self::Hnsw),
            "ivf" => Some(Self::Ivf),
            "flat" | "brute" => Some(Self::Flat),
            _ => None,
        }
    }

    /// Get the name of this index type.
    pub fn name(&self) -> &'static str {
        match self {
            Self::Hnsw => "hnsw",
            Self::Ivf => "ivf",
            Self::Flat => "flat",
        }
    }
}

/// Index parameters for building a vector index.
#[derive(Debug, Clone)]
pub struct IndexParams {
    /// Index type.
    pub index_type: IndexType,
    /// Distance metric.
    pub metric: DistanceMetric,
    /// HNSW M parameter (max neighbors per node at layer 0).
    pub hnsw_m: usize,
    /// HNSW ef_construction (beam width during build).
    pub hnsw_ef_construction: usize,
    /// HNSW ef_search (beam width during search).
    pub hnsw_ef_search: usize,
    /// IVF number of clusters.
    pub ivf_nlist: usize,
    /// IVF number of clusters to probe during search.
    pub ivf_nprobe: usize,
}

impl Default for IndexParams {
    fn default() -> Self {
        Self {
            index_type: IndexType::Hnsw,
            metric: DistanceMetric::Cosine,
            hnsw_m: 16,
            hnsw_ef_construction: 200,
            hnsw_ef_search: 50,
            ivf_nlist: 100,
            ivf_nprobe: 10,
        }
    }
}

/// Metadata about a vector index stored in dataset properties.
#[derive(Debug, Clone)]
pub struct VectorIndexMeta {
    /// Index type name.
    pub index_type: IndexType,
    /// Number of vectors indexed.
    pub vector_count: u64,
    /// Embedding dimensions.
    pub dimensions: u32,
    /// Distance metric.
    pub distance_metric: DistanceMetric,
    /// HNSW M parameter.
    pub hnsw_m: u16,
    /// HNSW ef_construction parameter.
    pub hnsw_ef_construction: u16,
    /// Maximum layer in the HNSW graph.
    pub max_layer: u8,
    /// Entry point object ID.
    pub entry_point: u64,
}

impl Default for VectorIndexMeta {
    fn default() -> Self {
        Self {
            index_type: IndexType::Hnsw,
            vector_count: 0,
            dimensions: 0,
            distance_metric: DistanceMetric::Cosine,
            hnsw_m: 16,
            hnsw_ef_construction: 200,
            max_layer: 0,
            entry_point: 0,
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// SEARCH FILTER
// ═══════════════════════════════════════════════════════════════════════════════

/// Filter for constraining vector search results.
#[derive(Debug, Clone, Default)]
pub struct SearchFilter {
    /// File extension filter (e.g., ["jpg", "png"]).
    pub extensions: Option<Vec<String>>,
    /// Minimum file size in bytes.
    pub min_size: Option<u64>,
    /// Maximum file size in bytes.
    pub max_size: Option<u64>,
    /// Modified after this timestamp (Unix seconds).
    pub modified_after: Option<u64>,
    /// Modified before this timestamp (Unix seconds).
    pub modified_before: Option<u64>,
    /// Path must start with this prefix.
    pub path_prefix: Option<String>,
    /// Minimum similarity score (0.0-1.0).
    pub min_score: Option<f32>,
}

impl SearchFilter {
    /// Create a new empty filter.
    pub fn new() -> Self {
        Self::default()
    }

    /// Filter by file extensions.
    pub fn with_extensions(mut self, extensions: Vec<String>) -> Self {
        self.extensions = Some(extensions);
        self
    }

    /// Filter by minimum size.
    pub fn with_min_size(mut self, size: u64) -> Self {
        self.min_size = Some(size);
        self
    }

    /// Filter by maximum size.
    pub fn with_max_size(mut self, size: u64) -> Self {
        self.max_size = Some(size);
        self
    }

    /// Filter by modification time.
    pub fn with_modified_after(mut self, timestamp: u64) -> Self {
        self.modified_after = Some(timestamp);
        self
    }

    /// Filter by path prefix.
    pub fn with_path_prefix(mut self, prefix: String) -> Self {
        self.path_prefix = Some(prefix);
        self
    }

    /// Filter by minimum score.
    pub fn with_min_score(mut self, score: f32) -> Self {
        self.min_score = Some(score);
        self
    }

    /// Check if a result passes this filter (basic check without file metadata).
    pub fn matches_basic(&self, result: &VectorSearchResult) -> bool {
        // Check minimum score
        if let Some(min_score) = self.min_score {
            if result.score < min_score {
                return false;
            }
        }

        // Check path prefix
        if let (Some(prefix), Some(path)) = (&self.path_prefix, &result.path) {
            if !path.starts_with(prefix) {
                return false;
            }
        }

        // Check extension
        if let (Some(extensions), Some(path)) = (&self.extensions, &result.path) {
            let has_valid_ext = extensions.iter().any(|ext| {
                path.to_lowercase()
                    .ends_with(&format!(".{}", ext.to_lowercase()))
            });
            if !has_valid_ext {
                return false;
            }
        }

        true
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// ERRORS
// ═══════════════════════════════════════════════════════════════════════════════

/// Errors that can occur during vector operations.
#[derive(Debug, Clone)]
pub enum VectorError {
    /// Embedding dimensions mismatch.
    DimensionMismatch {
        /// Expected dimensions.
        expected: usize,
        /// Actual dimensions.
        actual: usize,
    },
    /// Vector index not found.
    IndexNotFound,
    /// Object not found in index.
    ObjectNotFound(u64),
    /// Index is empty.
    EmptyIndex,
    /// Invalid quantization type.
    InvalidQuantization(u8),
    /// Serialization error.
    SerializationError,
    /// IO error.
    IoError(alloc::string::String),
    /// Index is corrupted.
    CorruptedIndex,
    /// Dataset not found.
    DatasetNotFound(String),
    /// Feature not supported.
    NotSupported(String),
}

impl core::fmt::Display for VectorError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::DimensionMismatch { expected, actual } => {
                write!(
                    f,
                    "dimension mismatch: expected {}, got {}",
                    expected, actual
                )
            }
            Self::IndexNotFound => write!(f, "vector index not found"),
            Self::ObjectNotFound(id) => write!(f, "object {} not found in index", id),
            Self::EmptyIndex => write!(f, "vector index is empty"),
            Self::InvalidQuantization(q) => write!(f, "invalid quantization type: {}", q),
            Self::SerializationError => write!(f, "serialization error"),
            Self::IoError(msg) => write!(f, "IO error: {}", msg),
            Self::CorruptedIndex => write!(f, "corrupted vector index"),
            Self::DatasetNotFound(name) => write!(f, "dataset not found: {}", name),
            Self::NotSupported(feature) => write!(f, "feature not supported: {}", feature),
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// TESTS
// ═══════════════════════════════════════════════════════════════════════════════

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_vector_embedding_header_serialization() {
        let header = VectorEmbeddingHeader::new(12345, 42, 512, QuantizationType::F32);
        let bytes = header.to_bytes();
        let restored = VectorEmbeddingHeader::from_bytes(&bytes);

        assert_eq!(restored.object_id, 12345);
        assert_eq!(restored.model_id, 42);
        assert_eq!(restored.dimensions, 512);
        assert_eq!(restored.quantization_type(), QuantizationType::F32);
    }

    #[test]
    fn test_vector_embedding_data_size() {
        let header_f32 = VectorEmbeddingHeader::new(1, 1, 512, QuantizationType::F32);
        assert_eq!(header_f32.data_size(), 512 * 4);

        let header_f16 = VectorEmbeddingHeader::new(1, 1, 512, QuantizationType::F16);
        assert_eq!(header_f16.data_size(), 512 * 2);

        let header_int8 = VectorEmbeddingHeader::new(1, 1, 512, QuantizationType::Int8);
        assert_eq!(header_int8.data_size(), 512 + 8);

        let header_binary = VectorEmbeddingHeader::new(1, 1, 512, QuantizationType::Binary);
        assert_eq!(header_binary.data_size(), 64);
    }

    #[test]
    fn test_hnsw_node_neighbors() {
        let mut node = HnswNode::new(1, 0);
        assert_eq!(node.neighbor_count, 0);

        assert!(node.add_neighbor(2));
        assert!(node.add_neighbor(3));
        assert!(node.add_neighbor(4));

        assert_eq!(node.neighbor_count, 3);
        assert!(node.has_neighbor(2));
        assert!(node.has_neighbor(3));
        assert!(!node.has_neighbor(5));

        assert!(node.remove_neighbor(3));
        assert_eq!(node.neighbor_count, 2);
        assert!(!node.has_neighbor(3));

        let neighbors = node.get_neighbors();
        assert_eq!(neighbors.len(), 2);
        assert_eq!(neighbors[0], 2);
        assert_eq!(neighbors[1], 4);
    }

    #[test]
    fn test_hnsw_node_serialization() {
        let mut node = HnswNode::new(12345, 2);
        node.add_neighbor(100);
        node.add_neighbor(200);
        node.add_neighbor(300);

        let bytes = node.to_bytes();
        let restored = HnswNode::from_bytes(&bytes);

        assert_eq!(restored.object_id, 12345);
        assert_eq!(restored.layer, 2);
        assert_eq!(restored.neighbor_count, 3);
        assert_eq!(restored.neighbors[0], 100);
        assert_eq!(restored.neighbors[1], 200);
        assert_eq!(restored.neighbors[2], 300);
    }

    #[test]
    fn test_vector_embedding_normalize() {
        let mut embedding = VectorEmbedding::new(1, 1, vec![3.0, 4.0]);
        embedding.normalize();

        let norm = embedding.l2_norm();
        assert!((norm - 1.0).abs() < 1e-6);
        assert!((embedding.data[0] - 0.6).abs() < 1e-6);
        assert!((embedding.data[1] - 0.8).abs() < 1e-6);
    }

    #[test]
    fn test_search_result_ordering() {
        let mut results = [
            VectorSearchResult::new(1, 0.5, 0.5),
            VectorSearchResult::new(2, 0.9, 0.1),
            VectorSearchResult::new(3, 0.7, 0.3),
        ];

        results.sort();

        // Higher score should come first
        assert_eq!(results[0].object_id, 2);
        assert_eq!(results[1].object_id, 3);
        assert_eq!(results[2].object_id, 1);
    }

    #[test]
    fn test_search_filter() {
        let filter = SearchFilter::new()
            .with_min_score(0.5)
            .with_extensions(vec!["jpg".into(), "png".into()]);

        let good = VectorSearchResult::with_path(1, "/photos/cat.jpg".into(), 0.8, 0.2);
        let low_score = VectorSearchResult::with_path(2, "/photos/dog.jpg".into(), 0.3, 0.7);
        let wrong_ext = VectorSearchResult::with_path(3, "/docs/readme.txt".into(), 0.9, 0.1);

        assert!(filter.matches_basic(&good));
        assert!(!filter.matches_basic(&low_score));
        assert!(!filter.matches_basic(&wrong_ext));
    }

    #[test]
    fn test_distance_metric_from_str() {
        assert_eq!(
            DistanceMetric::from_str("cosine"),
            Some(DistanceMetric::Cosine)
        );
        assert_eq!(
            DistanceMetric::from_str("L2"),
            Some(DistanceMetric::Euclidean)
        );
        assert_eq!(
            DistanceMetric::from_str("dot"),
            Some(DistanceMetric::DotProduct)
        );
        assert_eq!(DistanceMetric::from_str("invalid"), None);
    }
}