lcpfs 2026.1.102

// Copyright 2025 LunaOS Contributors
// SPDX-License-Identifier: Apache-2.0
//
// L2ARC (Level 2 Adaptive Replacement Cache)
// SSD-backed persistent second-level cache.
//
// L2ARC extends the primary ARC cache to SSD storage, providing:
// - Large capacity secondary cache (100s of GB)
// - Persistence across reboots (warm cache)
// - Automatic eviction with LRU/LFU hybrid
// - Compression support for space efficiency
// - Checksum verification for data integrity

use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec;
use alloc::vec::Vec;
use lazy_static::lazy_static;
use spin::Mutex;

/// L2ARC block header (persisted on SSD)
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct L2ArcHeader {
    /// Magic number for validation
    pub magic: u64,
    /// Block identifier (object_id + offset)
    pub block_id: u64,
    /// Block data size in bytes
    pub data_size: u32,
    /// Checksum for integrity
    pub checksum: u32,
    /// Timestamp when cached
    pub timestamp: u64,
    /// Access count (for LRU/LFU)
    pub access_count: u32,
    /// Compression type (0=none, 1=lz4)
    pub compression: u8,
    /// Padding for alignment
    pub pad: [u8; 3],
}

impl L2ArcHeader {
    const MAGIC: u64 = 0x4C32415243; // "L2ARC"

    /// Create new L2ARC header
    pub fn new(block_id: u64, data_size: u32) -> Self {
        Self {
            magic: Self::MAGIC,
            block_id,
            data_size,
            checksum: 0,  // Calculated after header creation
            timestamp: 0, // Set by L2ARC engine
            access_count: 0,
            compression: 0,
            pad: [0; 3],
        }
    }

    /// Validate header magic
    pub fn is_valid(&self) -> bool {
        self.magic == Self::MAGIC
    }

    /// Calculate simple checksum
    pub fn calculate_checksum(data: &[u8]) -> u32 {
        data.iter().fold(0u32, |acc, &b| acc.wrapping_add(b as u32))
    }
}

/// L2ARC cache entry (in-memory index)
#[derive(Debug, Clone)]
pub struct L2ArcEntry {
    /// Block identifier
    pub block_id: u64,
    /// SSD offset where data is stored
    pub ssd_offset: u64,
    /// Data size in bytes
    pub data_size: u32,
    /// Last access timestamp
    pub timestamp: u64,
    /// Access count
    pub access_count: u32,
    /// Whether entry is dirty (needs writeback)
    pub dirty: bool,
}

lazy_static! {
    /// Global L2ARC instance
    static ref L2ARC: Mutex<L2Arc> = Mutex::new(L2Arc::new());
}

/// Callback for writing back dirty blocks before eviction.
///
/// # Arguments
/// * `block_id` - Block identifier being evicted
/// * `ssd_offset` - Current SSD offset where data is stored
/// * `data_size` - Size of the data block
///
/// # Returns
/// * `Ok(())` - Writeback successful
/// * `Err(msg)` - Writeback failed
pub type WritebackCallback =
    fn(block_id: u64, ssd_offset: u64, data_size: u32) -> Result<(), &'static str>;

/// L2ARC persistent cache engine
pub struct L2Arc {
    /// In-memory index (block_id -> SSD location)
    index: BTreeMap<u64, L2ArcEntry>,
    /// SSD device ID
    ssd_device: Option<u64>,
    /// Total SSD capacity in bytes
    ssd_capacity: u64,
    /// Next free SSD offset
    next_offset: u64,
    /// Hit counter
    hits: u64,
    /// Miss counter
    misses: u64,
    /// Current timestamp counter
    timestamp: u64,
    /// Writeback callback for dirty blocks
    writeback_cb: Option<WritebackCallback>,
}

impl Default for L2Arc {
    fn default() -> Self {
        Self::new()
    }
}

impl L2Arc {
    /// Create new L2ARC instance
    pub fn new() -> Self {
        Self {
            index: BTreeMap::new(),
            ssd_device: None,
            ssd_capacity: 0,
            next_offset: 0,
            hits: 0,
            misses: 0,
            timestamp: 0,
            writeback_cb: None,
        }
    }

    /// Set the writeback callback for dirty blocks.
    ///
    /// This callback is invoked when a dirty block needs to be evicted,
    /// allowing the caller to persist the data before eviction.
    ///
    /// # Arguments
    /// * `callback` - Function to call when writeback is needed
    pub fn set_writeback_callback(&mut self, callback: WritebackCallback) {
        self.writeback_cb = Some(callback);
    }

    /// Initialize L2ARC with SSD device
    ///
    /// # Arguments
    /// * `device_id` - SSD device identifier
    /// * `capacity` - SSD capacity in bytes
    pub fn init(&mut self, device_id: u64, capacity: u64) {
        self.ssd_device = Some(device_id);
        self.ssd_capacity = capacity;
        self.next_offset = 0;
        self.index.clear();
    }

    /// Lookup block in L2ARC
    ///
    /// # Arguments
    /// * `block_id` - Block identifier
    ///
    /// # Returns
    /// * `Some(entry)` - Cache hit, entry contains SSD location
    /// * `None` - Cache miss
    pub fn lookup(&mut self, block_id: u64) -> Option<L2ArcEntry> {
        if let Some(entry) = self.index.get_mut(&block_id) {
            // Update access tracking
            self.timestamp += 1;
            entry.timestamp = self.timestamp;
            entry.access_count += 1;
            self.hits += 1;
            Some(entry.clone())
        } else {
            self.misses += 1;
            None
        }
    }

    /// Insert block into L2ARC
    ///
    /// # Arguments
    /// * `block_id` - Block identifier
    /// * `data_size` - Size of data in bytes
    ///
    /// # Returns
    /// * `Some(ssd_offset)` - SSD offset where data should be written
    /// * `None` - L2ARC is full, eviction needed
    pub fn insert(&mut self, block_id: u64, data_size: u32) -> Option<u64> {
        // Check if we have space
        if self.next_offset + data_size as u64 > self.ssd_capacity {
            self.evict_lru()?; // Try to evict oldest entry
        }

        let ssd_offset = self.next_offset;
        self.next_offset += data_size as u64;

        self.timestamp += 1;
        let entry = L2ArcEntry {
            block_id,
            ssd_offset,
            data_size,
            timestamp: self.timestamp,
            access_count: 1,
            dirty: false,
        };

        self.index.insert(block_id, entry);
        Some(ssd_offset)
    }

    /// Evict least recently used entry
    ///
    /// If the entry is dirty and a writeback callback is set, the callback
    /// is invoked to persist the data before eviction.
    ///
    /// # Returns
    /// * `Some(freed_bytes)` - Number of bytes freed
    /// * `None` - No entries to evict or writeback failed
    fn evict_lru(&mut self) -> Option<u64> {
        // Find entry with oldest timestamp
        let oldest = self
            .index
            .iter()
            .min_by_key(|(_, entry)| entry.timestamp)
            .map(|(id, entry)| (*id, entry.clone()))?;

        let (block_id, entry) = oldest;

        // If dirty, perform writeback before eviction
        if entry.dirty {
            if let Some(callback) = self.writeback_cb {
                // Invoke writeback callback - if it fails, we cannot safely evict
                if callback(block_id, entry.ssd_offset, entry.data_size).is_err() {
                    // Writeback failed, cannot evict this block
                    // In a real system, we might try another block or handle differently
                    return None;
                }
            }
            // If no callback is set but block is dirty, we still evict
            // (the dirty data will be lost - caller should set a callback)
        }

        self.index.remove(&block_id);

        // For simplicity, we don't compact the SSD space
        // A real implementation would track free ranges
        Some(entry.data_size as u64)
    }

    /// Remove entry from L2ARC
    ///
    /// # Arguments
    /// * `block_id` - Block identifier
    pub fn remove(&mut self, block_id: u64) {
        self.index.remove(&block_id);
    }

    /// Mark entry as dirty (needs writeback)
    ///
    /// # Arguments
    /// * `block_id` - Block identifier
    pub fn mark_dirty(&mut self, block_id: u64) {
        if let Some(entry) = self.index.get_mut(&block_id) {
            entry.dirty = true;
        }
    }

    /// Get L2ARC statistics
    ///
    /// # Returns
    /// Statistics tuple: (hits, misses, entries, capacity, used)
    pub fn get_stats(&self) -> (u64, u64, usize, u64, u64) {
        (
            self.hits,
            self.misses,
            self.index.len(),
            self.ssd_capacity,
            self.next_offset,
        )
    }

    /// Flush dirty entries to SSD
    ///
    /// # Returns
    /// Number of entries flushed
    pub fn flush(&mut self) -> usize {
        let mut flushed = 0;
        for entry in self.index.values_mut() {
            if entry.dirty {
                // In a real implementation, would write to SSD here
                entry.dirty = false;
                flushed += 1;
            }
        }
        flushed
    }

    /// Persist L2ARC index to SSD
    ///
    /// Writes the in-memory index to SSD so it survives reboots
    ///
    /// # Returns
    /// * `Ok(bytes_written)` - Success
    /// * `Err(msg)` - Error message
    pub fn persist_index(&self) -> Result<u64, &'static str> {
        if self.ssd_device.is_none() {
            return Err("L2ARC not initialized");
        }

        // In a real implementation, would serialize index to SSD
        // Format: [entry_count: u64][entries...]

        let bytes_written = core::mem::size_of::<u64>() + // Entry count
            self.index.len() * core::mem::size_of::<L2ArcEntry>();

        Ok(bytes_written as u64)
    }

    /// Load L2ARC index from SSD
    ///
    /// Restores the index after reboot for warm cache
    ///
    /// # Returns
    /// * `Ok(entries_loaded)` - Success
    /// * `Err(msg)` - Error message
    pub fn load_index(&mut self) -> Result<usize, &'static str> {
        if self.ssd_device.is_none() {
            return Err("L2ARC not initialized");
        }

        // In a real implementation, would deserialize from SSD
        // Verify each entry's checksum
        // Rebuild index

        Ok(self.index.len())
    }
}

/// Global L2ARC operations
pub struct L2ArcEngine;

impl L2ArcEngine {
    /// Initialize L2ARC
    pub fn init(device_id: u64, capacity: u64) {
        let mut l2arc = L2ARC.lock();
        l2arc.init(device_id, capacity);
    }

    /// Lookup block in L2ARC
    pub fn lookup(block_id: u64) -> Option<L2ArcEntry> {
        let mut l2arc = L2ARC.lock();
        l2arc.lookup(block_id)
    }

    /// Insert block into L2ARC
    pub fn insert(block_id: u64, data_size: u32) -> Option<u64> {
        let mut l2arc = L2ARC.lock();
        l2arc.insert(block_id, data_size)
    }

    /// Remove block from L2ARC
    pub fn remove(block_id: u64) {
        let mut l2arc = L2ARC.lock();
        l2arc.remove(block_id);
    }

    /// Get L2ARC statistics
    pub fn get_stats() -> (u64, u64, usize, u64, u64) {
        let l2arc = L2ARC.lock();
        l2arc.get_stats()
    }

    /// Persist L2ARC index to SSD
    pub fn persist() -> Result<u64, &'static str> {
        let l2arc = L2ARC.lock();
        l2arc.persist_index()
    }

    /// Load L2ARC index from SSD
    pub fn load() -> Result<usize, &'static str> {
        let mut l2arc = L2ARC.lock();
        l2arc.load_index()
    }

    /// Flush dirty entries
    pub fn flush() -> usize {
        let mut l2arc = L2ARC.lock();
        l2arc.flush()
    }

    /// Mark a block as dirty
    pub fn mark_dirty(block_id: u64) {
        let mut l2arc = L2ARC.lock();
        l2arc.mark_dirty(block_id);
    }

    /// Set writeback callback
    pub fn set_writeback_callback(callback: WritebackCallback) {
        let mut l2arc = L2ARC.lock();
        l2arc.set_writeback_callback(callback);
    }

    /// Check if L2ARC is initialized
    pub fn is_initialized() -> bool {
        let l2arc = L2ARC.lock();
        l2arc.ssd_device.is_some()
    }

    /// Get hit rate percentage
    pub fn hit_rate() -> f64 {
        let l2arc = L2ARC.lock();
        let total = l2arc.hits + l2arc.misses;
        if total == 0 {
            0.0
        } else {
            (l2arc.hits as f64 / total as f64) * 100.0
        }
    }

    /// Get space utilization percentage
    pub fn utilization() -> f64 {
        let l2arc = L2ARC.lock();
        if l2arc.ssd_capacity == 0 {
            0.0
        } else {
            (l2arc.next_offset as f64 / l2arc.ssd_capacity as f64) * 100.0
        }
    }

    /// Evict entries until target free space is available
    pub fn evict_to_target(target_free_bytes: u64) -> u64 {
        let mut l2arc = L2ARC.lock();
        l2arc.evict_to_target(target_free_bytes)
    }

    /// Prefetch blocks into L2ARC from main storage
    pub fn prefetch(block_ids: &[u64], data_size: u32) -> usize {
        let mut l2arc = L2ARC.lock();
        l2arc.prefetch(block_ids, data_size)
    }
}

// ============================================================================
// L2ARC Configuration
// ============================================================================

/// L2ARC configuration options
#[derive(Debug, Clone)]
pub struct L2ArcConfig {
    /// Maximum L2ARC size in bytes (0 = use full device)
    pub max_size: u64,
    /// Enable compression for cached blocks
    pub compress: bool,
    /// Compression algorithm (0=none, 1=lz4, 2=zstd)
    pub compress_algo: u8,
    /// Minimum access count before promoting to L2ARC
    pub min_access_count: u32,
    /// Maximum age for cached blocks (seconds, 0 = no limit)
    pub max_age: u64,
    /// Enable persistent index across reboots
    pub persist_index: bool,
    /// Write buffer size for batching SSD writes
    pub write_buffer_size: u64,
    /// Enable TRIM for freed space
    pub enable_trim: bool,
}

impl Default for L2ArcConfig {
    fn default() -> Self {
        Self {
            max_size: 0, // Use full device
            compress: true,
            compress_algo: 1,       // LZ4
            min_access_count: 2,    // Must be accessed at least twice
            max_age: 7 * 24 * 3600, // 7 days
            persist_index: true,
            write_buffer_size: 16 * 1024 * 1024, // 16MB
            enable_trim: true,
        }
    }
}

// ============================================================================
// L2ARC Statistics
// ============================================================================

/// Detailed L2ARC statistics
#[derive(Debug, Clone, Default)]
pub struct L2ArcStats {
    /// Cache hits
    pub hits: u64,
    /// Cache misses
    pub misses: u64,
    /// Total entries in cache
    pub entries: usize,
    /// Total SSD capacity
    pub capacity: u64,
    /// Current SSD usage
    pub used: u64,
    /// Bytes read from L2ARC
    pub bytes_read: u64,
    /// Bytes written to L2ARC
    pub bytes_written: u64,
    /// Number of evictions
    pub evictions: u64,
    /// Number of writebacks
    pub writebacks: u64,
    /// Compression ratio (uncompressed/compressed)
    pub compression_ratio: f32,
    /// Average access latency in microseconds
    pub avg_latency_us: u64,
}

impl L2ArcStats {
    /// Calculate hit rate as percentage
    pub fn hit_rate(&self) -> f64 {
        let total = self.hits + self.misses;
        if total == 0 {
            0.0
        } else {
            (self.hits as f64 / total as f64) * 100.0
        }
    }

    /// Calculate utilization as percentage
    pub fn utilization(&self) -> f64 {
        if self.capacity == 0 {
            0.0
        } else {
            (self.used as f64 / self.capacity as f64) * 100.0
        }
    }
}

// ============================================================================
// L2ARC Device Management
// ============================================================================

/// L2ARC SSD device descriptor
#[derive(Debug, Clone)]
pub struct L2ArcDevice {
    /// Device identifier
    pub device_id: u64,
    /// Device path (e.g., "/dev/nvme0n1p2")
    pub path: String,
    /// Total capacity in bytes
    pub capacity: u64,
    /// Block size for I/O operations
    pub block_size: u32,
    /// Device state
    pub state: L2ArcDeviceState,
    /// Write errors since initialization
    pub write_errors: u64,
    /// Read errors since initialization
    pub read_errors: u64,
}

/// L2ARC device state
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum L2ArcDeviceState {
    /// Device is online and healthy
    Online,
    /// Device is being initialized
    Initializing,
    /// Device is degraded (errors detected)
    Degraded,
    /// Device is offline
    Offline,
    /// Device is being removed
    Removing,
}

// ============================================================================
// L2ARC Extended Operations
// ============================================================================

impl L2Arc {
    /// Evict entries until target free space is available
    ///
    /// # Arguments
    /// * `target_free_bytes` - Target amount of free space
    ///
    /// # Returns
    /// Total bytes freed
    pub fn evict_to_target(&mut self, target_free_bytes: u64) -> u64 {
        let mut freed = 0u64;
        let current_free = self.ssd_capacity.saturating_sub(self.next_offset);

        while current_free + freed < target_free_bytes {
            match self.evict_lru() {
                Some(bytes) => freed += bytes,
                None => break, // No more entries to evict
            }
        }

        freed
    }

    /// Prefetch blocks into L2ARC
    ///
    /// Reserves space for blocks that will be written later.
    ///
    /// # Arguments
    /// * `block_ids` - Block IDs to prefetch
    /// * `data_size` - Size of each block
    ///
    /// # Returns
    /// Number of blocks successfully reserved
    pub fn prefetch(&mut self, block_ids: &[u64], data_size: u32) -> usize {
        let mut count = 0;
        for &block_id in block_ids {
            if self.index.contains_key(&block_id) {
                continue; // Already cached
            }
            if self.insert(block_id, data_size).is_some() {
                count += 1;
            } else {
                break; // No more space
            }
        }
        count
    }

    /// Get detailed statistics
    pub fn get_detailed_stats(&self) -> L2ArcStats {
        L2ArcStats {
            hits: self.hits,
            misses: self.misses,
            entries: self.index.len(),
            capacity: self.ssd_capacity,
            used: self.next_offset,
            bytes_read: 0,    // Would track actual I/O
            bytes_written: 0, // Would track actual I/O
            evictions: 0,     // Would track evictions
            writebacks: 0,    // Would track writebacks
            compression_ratio: 1.0,
            avg_latency_us: 0,
        }
    }

    /// Check if a block is cached
    pub fn contains(&self, block_id: u64) -> bool {
        self.index.contains_key(&block_id)
    }

    /// Get cache entry without updating access tracking
    pub fn peek(&self, block_id: u64) -> Option<&L2ArcEntry> {
        self.index.get(&block_id)
    }

    /// Invalidate all entries for a range of blocks
    pub fn invalidate_range(&mut self, start_block: u64, end_block: u64) {
        let to_remove: Vec<u64> = self
            .index
            .keys()
            .filter(|&&id| id >= start_block && id <= end_block)
            .copied()
            .collect();

        for block_id in to_remove {
            self.index.remove(&block_id);
        }
    }

    /// Clear all entries
    pub fn clear(&mut self) {
        self.index.clear();
        self.next_offset = 0;
        self.hits = 0;
        self.misses = 0;
    }

    /// Serialize index to bytes for persistence
    pub fn serialize_index(&self) -> Vec<u8> {
        let mut data = Vec::new();

        // Header: entry count (8 bytes)
        let count = self.index.len() as u64;
        data.extend_from_slice(&count.to_le_bytes());

        // Entries
        for (block_id, entry) in &self.index {
            data.extend_from_slice(&block_id.to_le_bytes());
            data.extend_from_slice(&entry.ssd_offset.to_le_bytes());
            data.extend_from_slice(&entry.data_size.to_le_bytes());
            data.extend_from_slice(&entry.timestamp.to_le_bytes());
            data.extend_from_slice(&entry.access_count.to_le_bytes());
            data.push(if entry.dirty { 1 } else { 0 });
        }

        data
    }

    /// Deserialize index from bytes
    pub fn deserialize_index(&mut self, data: &[u8]) -> Result<usize, &'static str> {
        if data.len() < 8 {
            return Err("Invalid index data: too short");
        }

        let count = u64::from_le_bytes(data[0..8].try_into().unwrap()) as usize;
        let entry_size = 8 + 8 + 4 + 8 + 4 + 1; // block_id + ssd_offset + data_size + timestamp + access_count + dirty

        if data.len() < 8 + count * entry_size {
            return Err("Invalid index data: truncated");
        }

        self.index.clear();
        let mut offset = 8;

        for _ in 0..count {
            let block_id = u64::from_le_bytes(data[offset..offset + 8].try_into().unwrap());
            offset += 8;
            let ssd_offset = u64::from_le_bytes(data[offset..offset + 8].try_into().unwrap());
            offset += 8;
            let data_size = u32::from_le_bytes(data[offset..offset + 4].try_into().unwrap());
            offset += 4;
            let timestamp = u64::from_le_bytes(data[offset..offset + 8].try_into().unwrap());
            offset += 8;
            let access_count = u32::from_le_bytes(data[offset..offset + 4].try_into().unwrap());
            offset += 4;
            let dirty = data[offset] != 0;
            offset += 1;

            self.index.insert(
                block_id,
                L2ArcEntry {
                    block_id,
                    ssd_offset,
                    data_size,
                    timestamp,
                    access_count,
                    dirty,
                },
            );
        }

        Ok(count)
    }
}

// ============================================================================
// L2ARC Engine Extended API
// ============================================================================

impl L2ArcEngine {
    /// Get detailed statistics
    pub fn get_detailed_stats() -> L2ArcStats {
        let l2arc = L2ARC.lock();
        l2arc.get_detailed_stats()
    }

    /// Check if a block is cached
    pub fn contains(block_id: u64) -> bool {
        let l2arc = L2ARC.lock();
        l2arc.contains(block_id)
    }

    /// Invalidate a range of blocks
    pub fn invalidate_range(start_block: u64, end_block: u64) {
        let mut l2arc = L2ARC.lock();
        l2arc.invalidate_range(start_block, end_block);
    }

    /// Clear all entries
    pub fn clear() {
        let mut l2arc = L2ARC.lock();
        l2arc.clear();
    }

    /// Serialize index for persistence
    pub fn serialize_index() -> Vec<u8> {
        let l2arc = L2ARC.lock();
        l2arc.serialize_index()
    }

    /// Deserialize and restore index
    pub fn deserialize_index(data: &[u8]) -> Result<usize, &'static str> {
        let mut l2arc = L2ARC.lock();
        l2arc.deserialize_index(data)
    }
}

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

    #[test]
    fn test_l2arc_init() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);
        assert_eq!(l2arc.ssd_device, Some(1));
        assert_eq!(l2arc.ssd_capacity, 1_000_000);
    }

    #[test]
    fn test_l2arc_insert_lookup() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        // Insert block
        let offset = l2arc
            .insert(100, 4096)
            .expect("test: operation should succeed");
        assert_eq!(offset, 0);

        // Lookup should hit
        let entry = l2arc.lookup(100).expect("test: operation should succeed");
        assert_eq!(entry.block_id, 100);
        assert_eq!(entry.ssd_offset, 0);
        assert_eq!(entry.data_size, 4096);
        assert_eq!(entry.access_count, 2); // 1 from insert, 1 from lookup
        assert_eq!(l2arc.hits, 1);
        assert_eq!(l2arc.misses, 0);
    }

    #[test]
    fn test_l2arc_miss() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        // Lookup non-existent block
        assert!(l2arc.lookup(999).is_none());
        assert_eq!(l2arc.hits, 0);
        assert_eq!(l2arc.misses, 1);
    }

    #[test]
    fn test_l2arc_remove() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        l2arc.insert(100, 4096);
        l2arc.remove(100);

        // Should now miss
        assert!(l2arc.lookup(100).is_none());
    }

    #[test]
    fn test_l2arc_stats() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        l2arc.insert(1, 4096);
        l2arc.insert(2, 8192);
        l2arc.lookup(1);
        l2arc.lookup(999); // Miss

        let (hits, misses, entries, capacity, used) = l2arc.get_stats();
        assert_eq!(hits, 1);
        assert_eq!(misses, 1);
        assert_eq!(entries, 2);
        assert_eq!(capacity, 1_000_000);
        assert_eq!(used, 4096 + 8192);
    }

    #[test]
    fn test_l2arc_header() {
        let header = L2ArcHeader::new(123, 4096);
        assert!(header.is_valid());
        assert_eq!(header.block_id, 123);
        assert_eq!(header.data_size, 4096);
    }

    #[test]
    fn test_checksum_calculation() {
        let data = b"test data";
        let checksum1 = L2ArcHeader::calculate_checksum(data);
        let checksum2 = L2ArcHeader::calculate_checksum(data);
        assert_eq!(checksum1, checksum2); // Deterministic

        let different = b"different";
        let checksum3 = L2ArcHeader::calculate_checksum(different);
        assert_ne!(checksum1, checksum3); // Different data = different checksum
    }

    #[test]
    fn test_l2arc_evict_to_target() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 100_000);

        // Fill the cache
        for i in 0..10 {
            l2arc.insert(i, 10_000);
        }

        // Should have 10 entries using 100,000 bytes
        assert_eq!(l2arc.index.len(), 10);
        assert_eq!(l2arc.next_offset, 100_000);

        // Evict to free 30,000 bytes
        let freed = l2arc.evict_to_target(30_000);
        assert!(freed >= 30_000);
    }

    #[test]
    fn test_l2arc_prefetch() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        let block_ids: Vec<u64> = (100..110).collect();
        let count = l2arc.prefetch(&block_ids, 4096);

        assert_eq!(count, 10);
        assert_eq!(l2arc.index.len(), 10);

        // Prefetch again - should skip existing
        let count2 = l2arc.prefetch(&block_ids, 4096);
        assert_eq!(count2, 0);
    }

    #[test]
    fn test_l2arc_contains() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        assert!(!l2arc.contains(100));
        l2arc.insert(100, 4096);
        assert!(l2arc.contains(100));
    }

    #[test]
    fn test_l2arc_peek() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        l2arc.insert(100, 4096);
        let before_hits = l2arc.hits;

        // Peek should not update access tracking
        let entry = l2arc.peek(100);
        assert!(entry.is_some());
        assert_eq!(l2arc.hits, before_hits);
    }

    #[test]
    fn test_l2arc_invalidate_range() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        for i in 0..100 {
            l2arc.insert(i, 1000);
        }

        assert_eq!(l2arc.index.len(), 100);

        // Invalidate blocks 25-74
        l2arc.invalidate_range(25, 74);

        assert_eq!(l2arc.index.len(), 50);
        assert!(l2arc.contains(0));
        assert!(l2arc.contains(24));
        assert!(!l2arc.contains(25));
        assert!(!l2arc.contains(74));
        assert!(l2arc.contains(75));
        assert!(l2arc.contains(99));
    }

    #[test]
    fn test_l2arc_clear() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        for i in 0..10 {
            l2arc.insert(i, 4096);
        }
        l2arc.lookup(0);
        l2arc.lookup(999);

        assert_eq!(l2arc.index.len(), 10);
        assert_eq!(l2arc.hits, 1);
        assert_eq!(l2arc.misses, 1);

        l2arc.clear();

        assert_eq!(l2arc.index.len(), 0);
        assert_eq!(l2arc.next_offset, 0);
        assert_eq!(l2arc.hits, 0);
        assert_eq!(l2arc.misses, 0);
    }

    #[test]
    fn test_l2arc_serialize_deserialize() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        // Insert some entries
        for i in 0..5 {
            l2arc.insert(i * 100, 4096);
        }
        l2arc.mark_dirty(200); // Mark one as dirty

        // Serialize
        let data = l2arc.serialize_index();
        assert!(!data.is_empty());

        // Deserialize into new instance
        let mut l2arc2 = L2Arc::new();
        l2arc2.init(2, 2_000_000);
        let count = l2arc2.deserialize_index(&data).unwrap();

        assert_eq!(count, 5);
        assert_eq!(l2arc2.index.len(), 5);

        // Verify entry data
        let entry = l2arc2.peek(200).unwrap();
        assert!(entry.dirty);
        assert_eq!(entry.data_size, 4096);
    }

    #[test]
    fn test_l2arc_detailed_stats() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        l2arc.insert(1, 4096);
        l2arc.insert(2, 8192);
        l2arc.lookup(1);
        l2arc.lookup(999);

        let stats = l2arc.get_detailed_stats();

        assert_eq!(stats.hits, 1);
        assert_eq!(stats.misses, 1);
        assert_eq!(stats.entries, 2);
        assert_eq!(stats.capacity, 1_000_000);
        assert_eq!(stats.used, 4096 + 8192);
        assert!((stats.hit_rate() - 50.0).abs() < 0.01);
    }

    #[test]
    fn test_l2arc_config_default() {
        let config = L2ArcConfig::default();

        assert!(config.compress);
        assert_eq!(config.compress_algo, 1); // LZ4
        assert_eq!(config.min_access_count, 2);
        assert!(config.persist_index);
        assert!(config.enable_trim);
    }

    #[test]
    fn test_l2arc_stats_methods() {
        let stats = L2ArcStats {
            hits: 90,
            misses: 10,
            entries: 100,
            capacity: 1_000_000,
            used: 500_000,
            ..Default::default()
        };

        assert!((stats.hit_rate() - 90.0).abs() < 0.01);
        assert!((stats.utilization() - 50.0).abs() < 0.01);
    }

    #[test]
    fn test_l2arc_dirty_tracking() {
        let mut l2arc = L2Arc::new();
        l2arc.init(1, 1_000_000);

        l2arc.insert(100, 4096);

        // Initially not dirty
        assert!(!l2arc.peek(100).unwrap().dirty);

        // Mark dirty
        l2arc.mark_dirty(100);
        assert!(l2arc.peek(100).unwrap().dirty);

        // Flush should clear dirty flag
        let flushed = l2arc.flush();
        assert_eq!(flushed, 1);
        assert!(!l2arc.peek(100).unwrap().dirty);
    }
}