speck-core 0.2.0

//! Storage layout calculation

use crate::error::{Error, Result};
use super::StorageConfig;

/// Calculated layout of flash regions
#[derive(Clone, Debug)]
pub struct StorageLayout {
    capacity: usize,
    page_size: usize,
    metadata_start: usize,
    journal_start: usize,
    slot_start: usize,
    slot_size: usize,
}

impl StorageLayout {
    /// Calculate layout for given capacity and config
    pub fn new(capacity: usize, config: &StorageConfig) -> Result<Self> {
        let page_size = 4096; // Assume 4KB pages
        
        // Reserve first page for metadata
        let metadata_start = 0;
        let journal_start = page_size;
        
        // Reserve 1 page for journal
        let slot_start = journal_start + page_size;
        let available = capacity.saturating_sub(slot_start);
        
        let slot_size = available / config.module_slots;
        if slot_size < config.max_module_size {
            return Err(Error::Storage(format!(
                "insufficient space: need {} per slot, have {}",
                config.max_module_size, slot_size
            )));
        }
        
        Ok(Self {
            capacity,
            page_size,
            metadata_start,
            journal_start,
            slot_start,
            slot_size,
        })
    }
    
    /// Get metadata region address
    pub fn metadata_address(&self) -> usize {
        self.metadata_start
    }
    
    /// Get journal region
    pub fn journal_region(&self) -> core::ops::Range<usize> {
        self.journal_start..self.slot_start
    }
    
    /// Get slot start address
    pub fn slot_address(&self, slot: usize) -> usize {
        self.slot_start + slot * self.slot_size
    }
    
    /// Get size of each slot
    pub fn slot_size(&self) -> usize {
        self.slot_size
    }
}