tron 2.1.0

//! Template assembly functionality for composing multiple templates.
//!
//! This module contains the [`TronAssembler`] struct, which allows you to
//! combine multiple [`TronRef`] templates into a single rendered output.
//! This is useful for building complex code generation scenarios where
//! different templates handle different parts of the output.
//!
//! # Examples
//!
//! Basic assembly:
//!
//! ```
//! use tron::{TronTemplate, TronRef, TronAssembler};
//!
//! let mut assembler = TronAssembler::new();
//!
//! // Add header template
//! let header = TronTemplate::new("// Generated code\nuse std::collections::HashMap;\n").unwrap();
//! assembler.add_template(TronRef::new(header));
//!
//! // Add function template
//! let func = TronTemplate::new("fn @[name]@() {\n    @[body]@\n}\n").unwrap();
//! let mut func_ref = TronRef::new(func);
//! func_ref.set("name", "example").unwrap();
//! func_ref.set("body", "println!(\"Hello from assembler!\");").unwrap();
//! assembler.add_template(func_ref);
//!
//! let result = assembler.render_all().unwrap();
//! ```

use crate::error::Result;
use crate::template_ref::TronRef;

/// Assemble multiple templates together.
///
/// `TronAssembler` allows you to combine multiple [`TronRef`] templates
/// into a single output. This is particularly useful for:
///
/// - Building complex code generation with header/body/footer structure
/// - Combining templates with different dependencies
/// - Setting common placeholder values across multiple templates
/// - Creating modular template architectures
///
/// # Examples
///
/// Creating a multi-part Rust module:
///
/// ```
/// use tron::{TronTemplate, TronRef, TronAssembler};
///
/// let mut assembler = TronAssembler::new();
///
/// // Add module declaration
/// let mod_decl = TronTemplate::new("pub mod @[module_name]@ {\n").unwrap();
/// let mut mod_ref = TronRef::new(mod_decl);
/// mod_ref.set("module_name", "generated").unwrap();
/// assembler.add_template(mod_ref);
///
/// // Add imports
/// let imports = TronTemplate::new("    use std::collections::HashMap;\n    use serde::{{Serialize, Deserialize}};\n").unwrap();
/// assembler.add_template(TronRef::new(imports));
///
/// // Add struct definition
/// let struct_def = TronTemplate::new("    \n    #[derive(Serialize, Deserialize)]\n    pub struct @[struct_name]@ {\n        @[fields]@\n    }\n").unwrap();
/// let mut struct_ref = TronRef::new(struct_def);
/// struct_ref.set("struct_name", "Config").unwrap();
/// struct_ref.set("fields", "pub name: String,\n        pub version: u32,").unwrap();
/// assembler.add_template(struct_ref);
///
/// // Close module
/// let mod_close = TronTemplate::new("}\n").unwrap();
/// assembler.add_template(TronRef::new(mod_close));
///
/// let result = assembler.render_all().unwrap();
/// ```
#[derive(Debug)]
pub struct TronAssembler {
    /// The templates to be assembled
    templates: Vec<TronRef>,
    /// Separator to use between templates (default: newline)
    separator: String,
}

impl TronAssembler {
    /// Create a new empty assembler.
    ///
    /// Templates will be separated by newlines when rendered.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::TronAssembler;
    ///
    /// let assembler = TronAssembler::new();
    /// assert_eq!(assembler.len(), 0);
    /// ```
    pub fn new() -> Self {
        Self {
            templates: Vec::new(),
            separator: "\n".to_string(),
        }
    }

    /// Create a new assembler with a custom separator.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::TronAssembler;
    ///
    /// let assembler = TronAssembler::with_separator("\n\n");
    /// // Templates will be separated by double newlines
    /// ```
    pub fn with_separator(separator: &str) -> Self {
        Self {
            templates: Vec::new(),
            separator: separator.to_string(),
        }
    }

    /// Get the current separator string.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::TronAssembler;
    ///
    /// let assembler = TronAssembler::new();
    /// assert_eq!(assembler.separator(), "\n");
    ///
    /// let assembler = TronAssembler::with_separator("---");
    /// assert_eq!(assembler.separator(), "---");
    /// ```
    pub fn separator(&self) -> &str {
        &self.separator
    }

    /// Set the separator string.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::TronAssembler;
    ///
    /// let mut assembler = TronAssembler::new();
    /// assembler.set_separator("\n\n// ---\n\n");
    /// ```
    pub fn set_separator(&mut self, separator: &str) {
        self.separator = separator.to_string();
    }

    /// Get the number of templates in the assembler.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// assert_eq!(assembler.len(), 0);
    ///
    /// let template = TronTemplate::new("Hello").unwrap();
    /// assembler.add_template(TronRef::new(template));
    /// assert_eq!(assembler.len(), 1);
    /// ```
    pub fn len(&self) -> usize {
        self.templates.len()
    }

    /// Check if the assembler is empty.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::TronAssembler;
    ///
    /// let assembler = TronAssembler::new();
    /// assert!(assembler.is_empty());
    /// ```
    pub fn is_empty(&self) -> bool {
        self.templates.is_empty()
    }

    /// Add a template reference to the assembler.
    ///
    /// Templates are rendered in the order they are added.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// let template = TronTemplate::new("Hello @[name]@!").unwrap();
    /// assembler.add_template(TronRef::new(template));
    /// ```
    pub fn add_template(&mut self, template: TronRef) {
        self.templates.push(template);
    }

    /// Add multiple templates at once.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// let templates = vec![
    ///     TronRef::new(TronTemplate::new("First").unwrap()),
    ///     TronRef::new(TronTemplate::new("Second").unwrap()),
    /// ];
    /// assembler.add_templates(templates);
    /// assert_eq!(assembler.len(), 2);
    /// ```
    pub fn add_templates<I>(&mut self, templates: I)
    where
        I: IntoIterator<Item = TronRef>,
    {
        for template in templates {
            self.templates.push(template);
        }
    }

    /// Insert a template at a specific position.
    ///
    /// # Panics
    ///
    /// Panics if `index` is greater than the number of templates.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// assembler.add_template(TronRef::new(TronTemplate::new("Second").unwrap()));
    /// assembler.insert_template(0, TronRef::new(TronTemplate::new("First").unwrap()));
    /// ```
    pub fn insert_template(&mut self, index: usize, template: TronRef) {
        self.templates.insert(index, template);
    }

    /// Remove a template at a specific position.
    ///
    /// Returns the removed template, or `None` if the index is out of bounds.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// assembler.add_template(TronRef::new(TronTemplate::new("Hello").unwrap()));
    /// let removed = assembler.remove_template(0);
    /// assert!(removed.is_some());
    /// assert!(assembler.is_empty());
    /// ```
    pub fn remove_template(&mut self, index: usize) -> Option<TronRef> {
        if index < self.templates.len() {
            Some(self.templates.remove(index))
        } else {
            None
        }
    }

    /// Clear all templates from the assembler.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// assembler.add_template(TronRef::new(TronTemplate::new("Hello").unwrap()));
    /// assembler.clear();
    /// assert!(assembler.is_empty());
    /// ```
    pub fn clear(&mut self) {
        self.templates.clear();
    }

    /// Get a reference to a template at a specific index.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// let template = TronRef::new(TronTemplate::new("Hello @[name]@!").unwrap());
    /// assembler.add_template(template);
    ///
    /// let template_ref = assembler.get(0).unwrap();
    /// assert!(template_ref.inner().has_placeholder("name"));
    /// ```
    pub fn get(&self, index: usize) -> Option<&TronRef> {
        self.templates.get(index)
    }

    /// Get a mutable reference to a template at a specific index.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// let template = TronRef::new(TronTemplate::new("Hello @[name]@!").unwrap());
    /// assembler.add_template(template);
    ///
    /// assembler.get_mut(0).unwrap().set("name", "World").unwrap();
    /// ```
    pub fn get_mut(&mut self, index: usize) -> Option<&mut TronRef> {
        self.templates.get_mut(index)
    }

    /// Set a value for a placeholder across all templates.
    ///
    /// This will set the placeholder value in any template that contains it.
    /// Templates that don't have the placeholder are left unchanged.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// assembler.add_template(TronRef::new(TronTemplate::new("Hello @[name]@!").unwrap()));
    /// assembler.add_template(TronRef::new(TronTemplate::new("Goodbye @[name]@!").unwrap()));
    ///
    /// assembler.set_global("name", "World").unwrap();
    /// let result = assembler.render_all().unwrap();
    /// assert!(result.contains("Hello World!"));
    /// assert!(result.contains("Goodbye World!"));
    /// ```
    pub fn set_global(&mut self, placeholder: &str, value: &str) -> Result<()> {
        for template in &mut self.templates {
            if template.inner().has_placeholder(placeholder) {
                template.set(placeholder, value)?;
            }
        }
        Ok(())
    }

    /// Set a template reference as a value for a placeholder across all templates.
    ///
    /// This will render the template reference and set the result as the
    /// placeholder value in any template that contains the placeholder.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// assembler.add_template(TronRef::new(TronTemplate::new("Header: @[content]@").unwrap()));
    /// assembler.add_template(TronRef::new(TronTemplate::new("Body: @[content]@").unwrap()));
    ///
    /// let content = TronTemplate::new("Generated at @[time]@").unwrap();
    /// let mut content_ref = TronRef::new(content);
    /// content_ref.set("time", "2024-01-01").unwrap();
    ///
    /// assembler.set_ref_global("content", content_ref).unwrap();
    /// let result = assembler.render_all().unwrap();
    /// assert!(result.contains("Generated at 2024-01-01"));
    /// ```
    pub fn set_ref_global(&mut self, placeholder: &str, template_ref: TronRef) -> Result<()> {
        for template in &mut self.templates {
            if template.inner().has_placeholder(placeholder) {
                template.set_ref(placeholder, template_ref.clone())?;
            }
        }
        Ok(())
    }

    /// Get all dependencies from all templates.
    ///
    /// This returns a deduplicated list of all dependencies from all
    /// templates in the assembler.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// 
    /// let template1 = TronRef::new(TronTemplate::new("fn main() {}").unwrap())
    ///     .with_dependency("serde = \"1.0\"");
    /// let template2 = TronRef::new(TronTemplate::new("fn other() {}").unwrap())
    ///     .with_dependency("tokio = \"1.0\"")
    ///     .with_dependency("serde = \"1.0\""); // duplicate
    ///
    /// assembler.add_template(template1);
    /// assembler.add_template(template2);
    ///
    /// let deps = assembler.all_dependencies();
    /// assert_eq!(deps.len(), 2); // deduplicated
    /// assert!(deps.contains(&"serde = \"1.0\"".to_string()));
    /// assert!(deps.contains(&"tokio = \"1.0\"".to_string()));
    /// ```
    pub fn all_dependencies(&self) -> Vec<String> {
        let mut deps = std::collections::HashSet::new();
        for template in &self.templates {
            for dep in template.dependencies() {
                deps.insert(dep.clone());
            }
        }
        deps.into_iter().collect()
    }

    /// Render all templates and combine them.
    ///
    /// Templates are rendered in the order they were added and joined
    /// with the separator string.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// 
    /// let mut template1 = TronRef::new(TronTemplate::new("Hello @[name]@!").unwrap());
    /// template1.set("name", "World").unwrap();
    ///
    /// let mut template2 = TronRef::new(TronTemplate::new("Goodbye @[name]@!").unwrap());
    /// template2.set("name", "World").unwrap();
    ///
    /// assembler.add_template(template1);
    /// assembler.add_template(template2);
    ///
    /// let result = assembler.render_all().unwrap();
    /// assert_eq!(result, "Hello World!\nGoodbye World!");
    /// ```
    ///
    /// # Errors
    ///
    /// Returns an error if any template fails to render.
    pub fn render_all(&self) -> Result<String> {
        if self.templates.is_empty() {
            return Ok(String::new());
        }

        let mut results = Vec::new();
        for template in &self.templates {
            results.push(template.render()?);
        }
        Ok(results.join(&self.separator))
    }

    /// Render all templates with partial placeholder filling.
    ///
    /// This is like [`render_all`] but uses partial rendering, allowing
    /// templates with unfilled placeholders.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    ///
    /// let mut template1 = TronRef::new(TronTemplate::new("Hello @[greeting]@ @[name]@!").unwrap());
    /// template1.set("greeting", "Hi").unwrap();
    /// // name is not set
    ///
    /// assembler.add_template(template1);
    /// let result = assembler.render_all_partial().unwrap();
    /// assert_eq!(result, "Hello Hi @[name]@!");
    /// ```
    pub fn render_all_partial(&self) -> Result<String> {
        if self.templates.is_empty() {
            return Ok(String::new());
        }

        let mut results = Vec::new();
        for template in &self.templates {
            results.push(template.render_partial()?);
        }
        Ok(results.join(&self.separator))
    }

    /// Create an iterator over the templates.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// assembler.add_template(TronRef::new(TronTemplate::new("Hello").unwrap()));
    /// assembler.add_template(TronRef::new(TronTemplate::new("World").unwrap()));
    ///
    /// let count = assembler.iter().count();
    /// assert_eq!(count, 2);
    /// ```
    pub fn iter(&self) -> std::slice::Iter<'_, TronRef> {
        self.templates.iter()
    }

    /// Create a mutable iterator over the templates.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef, TronAssembler};
    ///
    /// let mut assembler = TronAssembler::new();
    /// assembler.add_template(TronRef::new(TronTemplate::new("Hello @[name]@!").unwrap()));
    ///
    /// for template in assembler.iter_mut() {
    ///     if template.inner().has_placeholder("name") {
    ///         template.set("name", "World").unwrap();
    ///     }
    /// }
    /// ```
    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, TronRef> {
        self.templates.iter_mut()
    }
}

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

impl IntoIterator for TronAssembler {
    type Item = TronRef;
    type IntoIter = std::vec::IntoIter<TronRef>;

    fn into_iter(self) -> Self::IntoIter {
        self.templates.into_iter()
    }
}

impl<'a> IntoIterator for &'a TronAssembler {
    type Item = &'a TronRef;
    type IntoIter = std::slice::Iter<'a, TronRef>;

    fn into_iter(self) -> Self::IntoIter {
        self.templates.iter()
    }
}

impl<'a> IntoIterator for &'a mut TronAssembler {
    type Item = &'a mut TronRef;
    type IntoIter = std::slice::IterMut<'a, TronRef>;

    fn into_iter(self) -> Self::IntoIter {
        self.templates.iter_mut()
    }
}

impl FromIterator<TronRef> for TronAssembler {
    fn from_iter<I: IntoIterator<Item = TronRef>>(iter: I) -> Self {
        let mut assembler = TronAssembler::new();
        assembler.add_templates(iter);
        assembler
    }
}

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

    #[test]
    fn test_new_assembler() {
        let assembler = TronAssembler::new();
        assert_eq!(assembler.len(), 0);
        assert!(assembler.is_empty());
        assert_eq!(assembler.separator(), "\n");
    }

    #[test]
    fn test_with_separator() {
        let assembler = TronAssembler::with_separator("---");
        assert_eq!(assembler.separator(), "---");
    }

    #[test]
    fn test_add_template() -> Result<()> {
        let mut assembler = TronAssembler::new();
        let template = TronTemplate::new("Hello")?;
        assembler.add_template(TronRef::new(template));
        
        assert_eq!(assembler.len(), 1);
        assert!(!assembler.is_empty());
        Ok(())
    }

    #[test]
    fn test_add_templates() -> Result<()> {
        let mut assembler = TronAssembler::new();
        let templates = vec![
            TronRef::new(TronTemplate::new("First")?),
            TronRef::new(TronTemplate::new("Second")?),
        ];
        assembler.add_templates(templates);
        
        assert_eq!(assembler.len(), 2);
        Ok(())
    }

    #[test]
    fn test_render_all() -> Result<()> {
        let mut assembler = TronAssembler::new();
        
        let mut template1 = TronRef::new(TronTemplate::new("Hello @[name]@!")?);
        template1.set("name", "World")?;
        
        let mut template2 = TronRef::new(TronTemplate::new("Goodbye @[name]@!")?);
        template2.set("name", "World")?;
        
        assembler.add_template(template1);
        assembler.add_template(template2);
        
        let result = assembler.render_all()?;
        assert_eq!(result, "Hello World!\nGoodbye World!");
        Ok(())
    }

    #[test]
    fn test_set_global() -> Result<()> {
        let mut assembler = TronAssembler::new();
        assembler.add_template(TronRef::new(TronTemplate::new("Hello @[name]@!")?));
        assembler.add_template(TronRef::new(TronTemplate::new("Goodbye @[name]@!")?));
        
        assembler.set_global("name", "World")?;
        let result = assembler.render_all()?;
        assert!(result.contains("Hello World!"));
        assert!(result.contains("Goodbye World!"));
        Ok(())
    }

    #[test]
    fn test_template_composition() -> Result<()> {
        let mut assembler = TronAssembler::new();
        
        // Create a content template to be composed
        let content = TronTemplate::new("Generated at @[time]@")?;
        let mut content_ref = TronRef::new(content);
        content_ref.set("time", "2024-01-01")?;
        
        // Add templates that will use the content
        assembler.add_template(TronRef::new(TronTemplate::new("Header: @[content]@")?));
        assembler.add_template(TronRef::new(TronTemplate::new("Body: @[content]@")?));
        
        assembler.set_ref_global("content", content_ref)?;
        let result = assembler.render_all()?;
        
        assert!(result.contains("Header: Generated at 2024-01-01"));
        assert!(result.contains("Body: Generated at 2024-01-01"));
        Ok(())
    }

    #[test]
    fn test_all_dependencies() -> Result<()> {
        let mut assembler = TronAssembler::new();
        
        let template1 = TronRef::new(TronTemplate::new("fn main() {}")?)
            .with_dependency("serde = \"1.0\"");
        let template2 = TronRef::new(TronTemplate::new("fn other() {}")?)
            .with_dependency("tokio = \"1.0\"")
            .with_dependency("serde = \"1.0\""); // duplicate
        
        assembler.add_template(template1);
        assembler.add_template(template2);
        
        let deps = assembler.all_dependencies();
        assert_eq!(deps.len(), 2); // deduplicated
        assert!(deps.contains(&"serde = \"1.0\"".to_string()));
        assert!(deps.contains(&"tokio = \"1.0\"".to_string()));
        Ok(())
    }

    #[test]
    fn test_custom_separator() -> Result<()> {
        let mut assembler = TronAssembler::with_separator(" | ");
        
        assembler.add_template(TronRef::new(TronTemplate::new("First")?));
        assembler.add_template(TronRef::new(TronTemplate::new("Second")?));
        
        let result = assembler.render_all()?;
        assert_eq!(result, "First | Second");
        Ok(())
    }

    #[test]
    fn test_insert_and_remove() -> Result<()> {
        let mut assembler = TronAssembler::new();
        assembler.add_template(TronRef::new(TronTemplate::new("Second")?));
        assembler.insert_template(0, TronRef::new(TronTemplate::new("First")?));
        
        let result = assembler.render_all()?;
        assert_eq!(result, "First\nSecond");
        
        let removed = assembler.remove_template(0);
        assert!(removed.is_some());
        assert_eq!(assembler.len(), 1);
        Ok(())
    }

    #[test]
    fn test_empty_render() {
        let assembler = TronAssembler::new();
        let result = assembler.render_all().unwrap();
        assert_eq!(result, "");
    }

    #[test]
    fn test_render_partial() -> Result<()> {
        let mut assembler = TronAssembler::new();
        
        let mut template = TronRef::new(TronTemplate::new("Hello @[greeting]@ @[name]@!")?);
        template.set("greeting", "Hi")?;
        // name is not set
        
        assembler.add_template(template);
        let result = assembler.render_all_partial()?;
        assert_eq!(result, "Hello Hi @[name]@!");
        Ok(())
    }
}