blocks 0.1.0

use crate::block::Block;
use crate::converters::{ConversionFormat, Converter};
use crate::error::{BlocksError, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use uuid::Uuid;

/// Represents a document containing multiple blocks
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Document {
    /// Unique identifier for the document
    pub id: Uuid,
    /// Title of the document
    pub title: String,
    /// List of blocks in the document
    pub blocks: Vec<Block>,
    /// Document metadata
    pub metadata: HashMap<String, String>,
    /// Creation timestamp
    pub created_at: u64,
    /// Last modification timestamp
    pub updated_at: u64,
}

impl Document {
    /// Creates a new empty document
    ///
    /// # Example
    ///
    /// ```rust
    /// use blocks::Document;
    ///
    /// let doc = Document::new();
    /// assert!(doc.blocks.is_empty());
    /// ```
    pub fn new() -> Self {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();

        Self {
            id: Uuid::new_v4(),
            title: String::new(),
            blocks: Vec::new(),
            metadata: HashMap::new(),
            created_at: now,
            updated_at: now,
        }
    }

    /// Creates a new document with a title
    ///
    /// # Arguments
    ///
    /// * `title` - The title of the document
    ///
    /// # Example
    ///
    /// ```rust
    /// use blocks::Document;
    ///
    /// let doc = Document::with_title("My Document".to_string());
    /// assert_eq!(doc.title, "My Document");
    /// ```
    pub fn with_title(title: String) -> Self {
        let mut doc = Self::new();
        doc.title = title;
        doc
    }

    /// Adds a block to the document
    ///
    /// # Arguments
    ///
    /// * `block` - The block to add
    ///
    /// # Example
    ///
    /// ```rust
    /// use blocks::{Document, Block, BlockType};
    ///
    /// let mut doc = Document::new();
    /// let block = Block::new(BlockType::Text, "Hello".to_string());
    /// doc.add_block(block);
    /// assert_eq!(doc.blocks.len(), 1);
    /// ```
    pub fn add_block(&mut self, block: Block) {
        self.blocks.push(block);
        self.update_timestamp();
    }

    /// Inserts a block at a specific position
    ///
    /// # Arguments
    ///
    /// * `index` - The position to insert at
    /// * `block` - The block to insert
    ///
    /// # Returns
    ///
    /// `Result<(), BlocksError>` - Ok if successful, Err if index is out of bounds
    pub fn insert_block(&mut self, index: usize, block: Block) -> Result<()> {
        if index > self.blocks.len() {
            return Err(BlocksError::ValidationError {
                message: format!(
                    "Index {} is out of bounds for {} blocks",
                    index,
                    self.blocks.len()
                ),
            });
        }
        self.blocks.insert(index, block);
        self.update_timestamp();
        Ok(())
    }

    /// Removes a block by its ID
    ///
    /// # Arguments
    ///
    /// * `id` - The ID of the block to remove
    ///
    /// # Returns
    ///
    /// `Result<Block, BlocksError>` - The removed block if found
    pub fn remove_block(&mut self, id: Uuid) -> Result<Block> {
        let index = self.blocks.iter().position(|b| b.id == id).ok_or_else(|| {
            BlocksError::ValidationError {
                message: format!("Block with ID {id} not found"),
            }
        })?;

        let block = self.blocks.remove(index);
        self.update_timestamp();
        Ok(block)
    }

    /// Removes a block by index
    ///
    /// # Arguments
    ///
    /// * `index` - The index of the block to remove
    ///
    /// # Returns
    ///
    /// `Result<Block, BlocksError>` - The removed block if found
    pub fn remove_block_at(&mut self, index: usize) -> Result<Block> {
        if index >= self.blocks.len() {
            return Err(BlocksError::ValidationError {
                message: format!(
                    "Index {} is out of bounds for {} blocks",
                    index,
                    self.blocks.len()
                ),
            });
        }

        let block = self.blocks.remove(index);
        self.update_timestamp();
        Ok(block)
    }

    /// Gets a block by its ID
    ///
    /// # Arguments
    ///
    /// * `id` - The ID of the block to find
    ///
    /// # Returns
    ///
    /// `Option<&Block>` - The block if found
    pub fn get_block(&self, id: Uuid) -> Option<&Block> {
        self.blocks.iter().find(|b| b.id == id)
    }

    /// Gets a mutable reference to a block by its ID
    ///
    /// # Arguments
    ///
    /// * `id` - The ID of the block to find
    ///
    /// # Returns
    ///
    /// `Option<&mut Block>` - The mutable block if found
    pub fn get_block_mut(&mut self, id: Uuid) -> Option<&mut Block> {
        self.blocks.iter_mut().find(|b| b.id == id)
    }

    /// Gets a block by index
    ///
    /// # Arguments
    ///
    /// * `index` - The index of the block
    ///
    /// # Returns
    ///
    /// `Option<&Block>` - The block if found
    pub fn get_block_at(&self, index: usize) -> Option<&Block> {
        self.blocks.get(index)
    }

    /// Gets a mutable reference to a block by index
    ///
    /// # Arguments
    ///
    /// * `index` - The index of the block
    ///
    /// # Returns
    ///
    /// `Option<&mut Block>` - The mutable block if found
    pub fn get_block_at_mut(&mut self, index: usize) -> Option<&mut Block> {
        self.blocks.get_mut(index)
    }

    /// Returns the number of blocks in the document
    pub fn len(&self) -> usize {
        self.blocks.len()
    }

    /// Returns true if the document has no blocks
    pub fn is_empty(&self) -> bool {
        self.blocks.is_empty()
    }

    /// Validates all blocks in the document
    pub fn validate(&self) -> Result<()> {
        for (index, block) in self.blocks.iter().enumerate() {
            block.validate().map_err(|e| BlocksError::ValidationError {
                message: format!("Block {index} validation failed: {e}"),
            })?;
        }
        Ok(())
    }

    /// Converts the document to a specific format
    ///
    /// # Arguments
    ///
    /// * `format` - The format to convert to
    ///
    /// # Returns
    ///
    /// `Result<String, BlocksError>` - The converted document
    ///
    /// # Example
    ///
    /// ```rust
    /// use blocks::{Document, Block, BlockType, ConversionFormat};
    ///
    /// let mut doc = Document::new();
    /// doc.add_block(Block::new(BlockType::Text, "Hello".to_string()));
    /// let markdown = doc.to_format(ConversionFormat::Markdown).unwrap();
    /// assert!(markdown.contains("Hello"));
    /// ```
    pub fn to_format(&self, format: ConversionFormat) -> Result<String> {
        let converter = Converter::new(format);
        converter.convert(self)
    }

    /// Adds metadata to the document
    pub fn add_metadata(&mut self, key: String, value: String) {
        self.metadata.insert(key, value);
        self.update_timestamp();
    }

    /// Gets metadata from the document
    pub fn get_metadata(&self, key: &str) -> Option<&String> {
        self.metadata.get(key)
    }

    /// Updates the document title
    pub fn set_title(&mut self, title: String) {
        self.title = title;
        self.update_timestamp();
    }

    /// Updates the timestamp
    pub fn update_timestamp(&mut self) {
        self.updated_at = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();
    }

    /// Clears all blocks from the document
    pub fn clear(&mut self) {
        self.blocks.clear();
        self.update_timestamp();
    }
}

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

impl std::fmt::Display for Document {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Document: {} ({} blocks)", self.title, self.blocks.len())
    }
}

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

    #[test]
    fn test_document_creation() {
        let doc = Document::new();
        assert!(doc.blocks.is_empty());
        assert!(doc.title.is_empty());
        assert!(doc.metadata.is_empty());
    }

    #[test]
    fn test_document_with_title() {
        let doc = Document::with_title("Test Document".to_string());
        assert_eq!(doc.title, "Test Document");
    }

    #[test]
    fn test_add_block() {
        let mut doc = Document::new();
        let block = Block::new(BlockType::Text, "Hello".to_string());
        doc.add_block(block);
        assert_eq!(doc.blocks.len(), 1);
    }

    #[test]
    fn test_insert_block() {
        let mut doc = Document::new();
        let block1 = Block::new(BlockType::Text, "First".to_string());
        let block2 = Block::new(BlockType::Text, "Second".to_string());

        doc.add_block(block1);
        assert!(doc.insert_block(0, block2).is_ok());
        assert_eq!(doc.blocks.len(), 2);
        assert_eq!(doc.blocks[0].content, "Second");
    }

    #[test]
    fn test_insert_block_out_of_bounds() {
        let mut doc = Document::new();
        let block = Block::new(BlockType::Text, "Test".to_string());

        assert!(doc.insert_block(1, block).is_err());
    }

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

        let removed = doc.remove_block(id).unwrap();
        assert_eq!(removed.id, id);
        assert!(doc.blocks.is_empty());
    }

    #[test]
    fn test_remove_block_not_found() {
        let mut doc = Document::new();
        let id = Uuid::new_v4();

        assert!(doc.remove_block(id).is_err());
    }

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

        let removed = doc.remove_block_at(0).unwrap();
        assert_eq!(removed.content, "Test");
        assert!(doc.blocks.is_empty());
    }

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

        let found = doc.get_block(id).unwrap();
        assert_eq!(found.id, id);
    }

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

        let found = doc.get_block_at(0).unwrap();
        assert_eq!(found.content, "Test");
    }

    #[test]
    fn test_len_and_is_empty() {
        let mut doc = Document::new();
        assert_eq!(doc.len(), 0);
        assert!(doc.is_empty());

        doc.add_block(Block::new(BlockType::Text, "Test".to_string()));
        assert_eq!(doc.len(), 1);
        assert!(!doc.is_empty());
    }

    #[test]
    fn test_clear() {
        let mut doc = Document::new();
        doc.add_block(Block::new(BlockType::Text, "Test".to_string()));
        assert!(!doc.is_empty());

        doc.clear();
        assert!(doc.is_empty());
    }

    #[test]
    fn test_metadata() {
        let mut doc = Document::new();
        doc.add_metadata("author".to_string(), "John Doe".to_string());

        assert_eq!(doc.get_metadata("author"), Some(&"John Doe".to_string()));
        assert_eq!(doc.get_metadata("nonexistent"), None);
    }

    #[test]
    fn test_set_title() {
        let mut doc = Document::new();
        doc.set_title("New Title".to_string());
        assert_eq!(doc.title, "New Title");
    }

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

        let display = format!("{doc}");
        assert!(display.contains("Test Doc"));
        assert!(display.contains("1 blocks"));
    }

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

        let json = serde_json::to_string(&doc).unwrap();
        let deserialized: Document = serde_json::from_str(&json).unwrap();
        assert_eq!(doc, deserialized);
    }
}