blocks 0.1.0

/// Middleware and Pipeline module for block processing
///
/// Provides composable middleware chains for processing blocks and documents.
use crate::block::Block;
use crate::document::Document;
use crate::error::{BlocksError, Result};
use std::sync::Arc;

/// Type alias for middleware function
pub type MiddlewareFn = Arc<dyn Fn(&mut Block) -> Result<()> + Send + Sync>;

/// Type alias for document middleware function
pub type DocumentMiddlewareFn = Arc<dyn Fn(&mut Document) -> Result<()> + Send + Sync>;

/// Pipeline for processing blocks through multiple middleware stages
///
/// # Example
///
/// ```rust
/// use blocks::pipeline::BlockPipeline;
///
/// let pipeline = BlockPipeline::new()
///     .add_middleware(|block| {
///         block.content = block.content.trim().to_string();
///         Ok(())
///     })
///     .add_middleware(|block| {
///         block.content = block.content.to_uppercase();
///         Ok(())
///     });
/// ```
pub struct BlockPipeline {
    middlewares: Vec<MiddlewareFn>,
    name: String,
}

impl BlockPipeline {
    /// Creates a new empty pipeline
    pub fn new() -> Self {
        Self {
            middlewares: Vec::new(),
            name: "default".to_string(),
        }
    }

    /// Creates a new pipeline with a name
    pub fn with_name(name: impl Into<String>) -> Self {
        Self {
            middlewares: Vec::new(),
            name: name.into(),
        }
    }

    /// Adds a middleware function to the pipeline
    pub fn add_middleware<F>(mut self, middleware: F) -> Self
    where
        F: Fn(&mut Block) -> Result<()> + Send + Sync + 'static,
    {
        self.middlewares.push(Arc::new(middleware));
        self
    }

    /// Processes a block through all middleware in the pipeline
    pub fn process(&self, block: &mut Block) -> Result<()> {
        for middleware in &self.middlewares {
            middleware(block)?;
        }
        Ok(())
    }

    /// Processes multiple blocks through the pipeline
    pub fn process_all(&self, blocks: &mut [Block]) -> Result<()> {
        for block in blocks {
            self.process(block)?;
        }
        Ok(())
    }

    /// Returns the pipeline name
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Returns the number of middleware in the pipeline
    pub fn len(&self) -> usize {
        self.middlewares.len()
    }

    /// Returns true if the pipeline is empty
    pub fn is_empty(&self) -> bool {
        self.middlewares.is_empty()
    }
}

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

/// Pipeline for processing documents through multiple middleware stages
pub struct DocumentPipeline {
    middlewares: Vec<DocumentMiddlewareFn>,
    block_pipeline: Option<BlockPipeline>,
    name: String,
}

impl DocumentPipeline {
    /// Creates a new empty document pipeline
    pub fn new() -> Self {
        Self {
            middlewares: Vec::new(),
            block_pipeline: None,
            name: "default".to_string(),
        }
    }

    /// Creates a new pipeline with a name
    pub fn with_name(name: impl Into<String>) -> Self {
        Self {
            middlewares: Vec::new(),
            block_pipeline: None,
            name: name.into(),
        }
    }

    /// Adds a middleware function to the pipeline
    pub fn add_middleware<F>(mut self, middleware: F) -> Self
    where
        F: Fn(&mut Document) -> Result<()> + Send + Sync + 'static,
    {
        self.middlewares.push(Arc::new(middleware));
        self
    }

    /// Sets a block pipeline to process each block
    pub fn with_block_pipeline(mut self, pipeline: BlockPipeline) -> Self {
        self.block_pipeline = Some(pipeline);
        self
    }

    /// Processes a document through all middleware in the pipeline
    pub fn process(&self, doc: &mut Document) -> Result<()> {
        // First, process document-level middleware
        for middleware in &self.middlewares {
            middleware(doc)?;
        }

        // Then, if there's a block pipeline, process each block
        if let Some(ref block_pipeline) = self.block_pipeline {
            for block in &mut doc.blocks {
                block_pipeline.process(block)?;
            }
        }

        Ok(())
    }

    /// Returns the pipeline name
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Returns the number of middleware in the pipeline
    pub fn len(&self) -> usize {
        self.middlewares.len()
    }

    /// Returns true if the pipeline is empty
    pub fn is_empty(&self) -> bool {
        self.middlewares.is_empty() && self.block_pipeline.is_none()
    }
}

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

/// Common middleware functions for blocks
pub mod block_middlewares {
    use super::*;
    use crate::BlockType;

    /// Trims whitespace from block content
    pub fn trim_content() -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        |block| {
            block.content = block.content.trim().to_string();
            Ok(())
        }
    }

    /// Converts content to uppercase
    pub fn uppercase() -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        |block| {
            block.content = block.content.to_uppercase();
            Ok(())
        }
    }

    /// Converts content to lowercase
    pub fn lowercase() -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        |block| {
            block.content = block.content.to_lowercase();
            Ok(())
        }
    }

    /// Adds a prefix to text blocks
    pub fn add_prefix(prefix: String) -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        move |block| {
            if matches!(block.block_type, BlockType::Text) {
                block.content = format!("{}{}", prefix, block.content);
            }
            Ok(())
        }
    }

    /// Adds a suffix to text blocks
    pub fn add_suffix(suffix: String) -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        move |block| {
            if matches!(block.block_type, BlockType::Text) {
                block.content = format!("{}{}", block.content, suffix);
            }
            Ok(())
        }
    }

    /// Validates block content is not empty
    pub fn require_content() -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        |block| {
            if block.content.trim().is_empty() {
                return Err(BlocksError::EmptyContent {
                    block_type: block.type_name().to_string(),
                });
            }
            Ok(())
        }
    }

    /// Limits content length
    pub fn max_length(max: usize) -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        move |block| {
            if block.content.len() > max {
                block.content = block.content.chars().take(max).collect();
            }
            Ok(())
        }
    }

    /// Replaces text in content
    pub fn replace_text(
        from: String,
        to: String,
    ) -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        move |block| {
            block.content = block.content.replace(&from, &to);
            Ok(())
        }
    }

    /// Adds metadata to block
    pub fn add_metadata(
        key: String,
        value: String,
    ) -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        move |block| {
            block.metadata.insert(key.clone(), value.clone());
            Ok(())
        }
    }

    /// Adds timestamp metadata
    pub fn timestamp_metadata() -> impl Fn(&mut Block) -> Result<()> + Send + Sync + 'static {
        |block| {
            let now = std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs();
            block
                .metadata
                .insert("processed_at".to_string(), now.to_string());
            Ok(())
        }
    }
}

/// Common middleware functions for documents
pub mod document_middlewares {
    use super::*;

    /// Sets document title if empty
    pub fn default_title(
        title: String,
    ) -> impl Fn(&mut Document) -> Result<()> + Send + Sync + 'static {
        move |doc| {
            if doc.title.is_empty() {
                doc.title = title.clone();
            }
            Ok(())
        }
    }

    /// Adds metadata to document
    pub fn add_metadata(
        key: String,
        value: String,
    ) -> impl Fn(&mut Document) -> Result<()> + Send + Sync + 'static {
        move |doc| {
            doc.metadata.insert(key.clone(), value.clone());
            Ok(())
        }
    }

    /// Validates document has at least one block
    pub fn require_blocks() -> impl Fn(&mut Document) -> Result<()> + Send + Sync + 'static {
        |doc| {
            if doc.blocks.is_empty() {
                return Err(BlocksError::ValidationError {
                    message: "Document must have at least one block".to_string(),
                });
            }
            Ok(())
        }
    }

    /// Removes empty blocks from document
    pub fn remove_empty_blocks() -> impl Fn(&mut Document) -> Result<()> + Send + Sync + 'static {
        |doc| {
            doc.blocks.retain(|block| !block.content.trim().is_empty());
            Ok(())
        }
    }

    /// Limits number of blocks
    pub fn max_blocks(max: usize) -> impl Fn(&mut Document) -> Result<()> + Send + Sync + 'static {
        move |doc| {
            if doc.blocks.len() > max {
                doc.blocks.truncate(max);
            }
            Ok(())
        }
    }

    /// Adds processing timestamp
    pub fn timestamp_metadata() -> impl Fn(&mut Document) -> Result<()> + Send + Sync + 'static {
        |doc| {
            let now = std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs();
            doc.metadata
                .insert("processed_at".to_string(), now.to_string());
            Ok(())
        }
    }

    /// Sorts blocks by type
    pub fn sort_by_type() -> impl Fn(&mut Document) -> Result<()> + Send + Sync + 'static {
        |doc| {
            doc.blocks.sort_by(|a, b| a.type_name().cmp(b.type_name()));
            Ok(())
        }
    }
}

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

    #[test]
    fn test_block_pipeline_creation() {
        let pipeline = BlockPipeline::new();
        assert!(pipeline.is_empty());
        assert_eq!(pipeline.len(), 0);
    }

    #[test]
    fn test_block_pipeline_with_middleware() {
        let pipeline = BlockPipeline::new()
            .add_middleware(|block| {
                block.content = block.content.trim().to_string();
                Ok(())
            })
            .add_middleware(|block| {
                block.content = block.content.to_uppercase();
                Ok(())
            });

        assert_eq!(pipeline.len(), 2);
    }

    #[test]
    fn test_block_pipeline_processing() {
        let pipeline = BlockPipeline::new()
            .add_middleware(block_middlewares::trim_content())
            .add_middleware(block_middlewares::uppercase());

        let mut block = Block::new(BlockType::Text, "  hello world  ".to_string());
        pipeline.process(&mut block).unwrap();

        assert_eq!(block.content, "HELLO WORLD");
    }

    #[test]
    fn test_document_pipeline_creation() {
        let pipeline = DocumentPipeline::new();
        assert!(pipeline.is_empty());
    }

    #[test]
    fn test_document_pipeline_processing() {
        let block_pipeline = BlockPipeline::new().add_middleware(block_middlewares::trim_content());

        let doc_pipeline = DocumentPipeline::new()
            .add_middleware(document_middlewares::default_title("Untitled".to_string()))
            .with_block_pipeline(block_pipeline);

        let mut doc = Document::new();
        doc.add_block(Block::new(BlockType::Text, "  content  ".to_string()));

        doc_pipeline.process(&mut doc).unwrap();

        assert_eq!(doc.title, "Untitled");
        assert_eq!(doc.blocks[0].content, "content");
    }

    #[test]
    fn test_block_middlewares() {
        let mut block = Block::new(BlockType::Text, "Hello".to_string());

        // Test prefix
        let add_prefix = block_middlewares::add_prefix("[PREFIX] ".to_string());
        add_prefix(&mut block).unwrap();
        assert!(block.content.starts_with("[PREFIX]"));

        // Test max length
        let mut long_block = Block::new(BlockType::Text, "a".repeat(1000));
        let max_length = block_middlewares::max_length(100);
        max_length(&mut long_block).unwrap();
        assert_eq!(long_block.content.len(), 100);
    }

    #[test]
    fn test_document_middlewares() {
        let mut doc = Document::new();
        doc.add_block(Block::new(BlockType::Text, "".to_string()));
        doc.add_block(Block::new(BlockType::Text, "content".to_string()));
        doc.add_block(Block::new(BlockType::Text, "   ".to_string()));

        // Remove empty blocks
        let remove_empty = document_middlewares::remove_empty_blocks();
        remove_empty(&mut doc).unwrap();

        assert_eq!(doc.blocks.len(), 1);
        assert_eq!(doc.blocks[0].content, "content");
    }

    #[test]
    fn test_pipeline_with_name() {
        let pipeline = BlockPipeline::with_name("my-pipeline");
        assert_eq!(pipeline.name(), "my-pipeline");
    }

    #[test]
    fn test_process_all_blocks() {
        let pipeline = BlockPipeline::new().add_middleware(block_middlewares::uppercase());

        let mut blocks = vec![
            Block::new(BlockType::Text, "hello".to_string()),
            Block::new(BlockType::Text, "world".to_string()),
        ];

        pipeline.process_all(&mut blocks).unwrap();

        assert_eq!(blocks[0].content, "HELLO");
        assert_eq!(blocks[1].content, "WORLD");
    }

    #[test]
    fn test_require_content_middleware() {
        let require = block_middlewares::require_content();

        let mut valid = Block::new(BlockType::Text, "content".to_string());
        assert!(require(&mut valid).is_ok());

        let mut empty = Block::new(BlockType::Text, "   ".to_string());
        assert!(require(&mut empty).is_err());
    }

    #[test]
    fn test_metadata_middleware() {
        let add_meta = block_middlewares::add_metadata("key".to_string(), "value".to_string());

        let mut block = Block::new(BlockType::Text, "test".to_string());
        add_meta(&mut block).unwrap();

        assert_eq!(block.metadata.get("key"), Some(&"value".to_string()));
    }
}