tron 2.1.0

//! Template reference functionality with execution capabilities.
//!
//! This module contains the [`TronRef`] struct, which wraps a [`TronTemplate`]
//! with additional capabilities like dependency management and rust-script
//! execution.
//!
//! # Examples
//!
//! Basic template reference usage:
//!
//! ```
//! use tron::{TronTemplate, TronRef};
//!
//! let template = TronTemplate::new("fn main() { @[body]@ }").unwrap();
//! let mut template_ref = TronRef::new(template)
//!     .with_dependency("serde = \"1.0\"");
//!
//! template_ref.set("body", "println!(\"Hello, World!\");").unwrap();
//! let result = template_ref.render().unwrap();
//! ```

use crate::error::{Result, TronError};
use crate::template::TronTemplate;

/// A reference to a template that can be executed or composed.
///
/// `TronRef` wraps a [`TronTemplate`] with additional functionality including:
/// - Dependency management for rust-script execution
/// - Template composition capabilities
/// - Execution via rust-script (when the `execute` feature is enabled)
///
/// # Examples
///
/// Creating and using a template reference:
///
/// ```
/// use tron::{TronTemplate, TronRef};
///
/// let template = TronTemplate::new("fn @[name]@() { @[body]@ }").unwrap();
/// let mut template_ref = TronRef::new(template)
///     .with_dependency("chrono = \"0.4\"")
///     .with_dependency("serde = \"1.0\"");
///
/// template_ref.set("name", "current_time").unwrap();
/// template_ref.set("body", "println!(\"{}\", chrono::Utc::now());").unwrap();
/// ```
#[derive(Debug, Clone)]
pub struct TronRef {
    /// The wrapped template
    template: TronTemplate,
    /// Dependencies that will be included in rust-script execution
    dependencies: Vec<String>,
}

impl TronRef {
    /// Create a new template reference from a template.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("Hello @[name]@!").unwrap();
    /// let template_ref = TronRef::new(template);
    /// ```
    pub fn new(template: TronTemplate) -> Self {
        Self {
            template,
            dependencies: Vec::new(),
        }
    }

    /// Add a dependency that will be included in rust-script execution.
    ///
    /// Dependencies should be in Cargo.toml format (e.g., "serde = \"1.0\"").
    /// These dependencies are only used when executing templates with rust-script.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("fn main() { @[body]@ }").unwrap();
    /// let template_ref = TronRef::new(template)
    ///     .with_dependency("serde = \"1.0\"")
    ///     .with_dependency("tokio = { version = \"1.0\", features = [\"full\"] }");
    /// ```
    pub fn with_dependency(mut self, dependency: &str) -> Self {
        self.dependencies.push(dependency.to_string());
        self
    }

    /// Add multiple dependencies at once.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("fn main() { @[body]@ }").unwrap();
    /// let template_ref = TronRef::new(template)
    ///     .with_dependencies(&[
    ///         "serde = \"1.0\"",
    ///         "tokio = \"1.0\"",
    ///         "reqwest = \"0.11\"",
    ///     ]);
    /// ```
    pub fn with_dependencies<I, S>(mut self, dependencies: I) -> Self
    where
        I: IntoIterator<Item = S>,
        S: AsRef<str>,
    {
        for dep in dependencies {
            self.dependencies.push(dep.as_ref().to_string());
        }
        self
    }

    /// Add a dependency to an existing template reference.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("fn main() { @[body]@ }").unwrap();
    /// let mut template_ref = TronRef::new(template);
    /// template_ref.add_dependency("serde = \"1.0\"");
    /// ```
    pub fn add_dependency(&mut self, dependency: &str) {
        self.dependencies.push(dependency.to_string());
    }

    /// Get the list of dependencies.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("fn main() {}").unwrap();
    /// let template_ref = TronRef::new(template)
    ///     .with_dependency("serde = \"1.0\"");
    ///
    /// assert_eq!(template_ref.dependencies(), &["serde = \"1.0\""]);
    /// ```
    pub fn dependencies(&self) -> &[String] {
        &self.dependencies
    }

    /// Clear all dependencies.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("fn main() {}").unwrap();
    /// let mut template_ref = TronRef::new(template)
    ///     .with_dependency("serde = \"1.0\"");
    ///
    /// template_ref.clear_dependencies();
    /// assert!(template_ref.dependencies().is_empty());
    /// ```
    pub fn clear_dependencies(&mut self) {
        self.dependencies.clear();
    }

    /// Get a reference to the inner template.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("Hello @[name]@!").unwrap();
    /// let template_ref = TronRef::new(template);
    ///
    /// assert!(template_ref.inner().has_placeholder("name"));
    /// ```
    pub fn inner(&self) -> &TronTemplate {
        &self.template
    }

    /// Get a mutable reference to the inner template.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("Hello @[name]@!").unwrap();
    /// let mut template_ref = TronRef::new(template);
    ///
    /// template_ref.inner_mut().set("name", "World").unwrap();
    /// ```
    pub fn inner_mut(&mut self) -> &mut TronTemplate {
        &mut self.template
    }

    /// Set a placeholder value in the wrapped template.
    ///
    /// This is a convenience method that delegates to the inner template's
    /// [`set`](TronTemplate::set) method.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("Hello @[name]@!").unwrap();
    /// let mut template_ref = TronRef::new(template);
    /// template_ref.set("name", "World").unwrap();
    /// ```
    pub fn set(&mut self, placeholder: &str, value: &str) -> Result<()> {
        self.template.set(placeholder, value)
    }

    /// Set a placeholder to use another template reference.
    ///
    /// This renders the other template reference and uses the result as the
    /// placeholder value. Dependencies from the other template are merged
    /// into this one.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// // Create outer template
    /// let outer = TronTemplate::new("mod @[name]@ {\n    @[content]@\n}").unwrap();
    /// let mut outer_ref = TronRef::new(outer);
    ///
    /// // Create inner template
    /// let inner = TronTemplate::new("fn @[func_name]@() {\n    @[body]@\n}").unwrap();
    /// let mut inner_ref = TronRef::new(inner)
    ///     .with_dependency("serde = \"1.0\"");
    ///
    /// inner_ref.set("func_name", "example").unwrap();
    /// inner_ref.set("body", "println!(\"Hello!\");").unwrap();
    ///
    /// // Compose templates
    /// outer_ref.set("name", "generated").unwrap();
    /// outer_ref.set_ref("content", inner_ref).unwrap();
    ///
    /// let result = outer_ref.render().unwrap();
    /// // Dependencies from inner_ref are now available in outer_ref
    /// assert!(outer_ref.dependencies().contains(&"serde = \"1.0\"".to_string()));
    /// ```
    pub fn set_ref(&mut self, placeholder: &str, template_ref: TronRef) -> Result<()> {
        // First render the template we're inserting
        let rendered = template_ref.template.render()?;
        
        // Set the rendered content as the placeholder value
        self.template.set(placeholder, &rendered)?;

        // Merge dependencies
        self.dependencies.extend(template_ref.dependencies);
        
        Ok(())
    }

    /// Execute the template with rust-script.
    ///
    /// This feature requires:
    /// 1. The `execute` feature to be enabled
    /// 2. rust-script to be installed (`cargo install rust-script`)
    ///
    /// The template is rendered, dependencies are added as a Cargo script block,
    /// and the result is executed using rust-script.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new(
    ///     "fn main() {\n    println!(\"Current time: {}\", now());\n}\n\nfn now() -> String {\n    @[body]@\n}"
    /// ).unwrap();
    ///
    /// let mut template_ref = TronRef::new(template)
    ///     .with_dependency("chrono = \"0.4\"");
    ///
    /// template_ref.set("body", "chrono::Utc::now().to_string()").unwrap();
    ///
    /// # #[cfg(feature = "execute")]
    /// # tokio_test::block_on(async {
    /// let output = template_ref.execute().await.unwrap();
    /// println!("Execution output: {}", output);
    /// # });
    /// ```
    ///
    /// # Errors
    ///
    /// Returns [`TronError::ExecutionError`] if:
    /// - rust-script is not installed
    /// - The generated code has compilation errors  
    /// - The execution fails for any other reason
    #[cfg(feature = "execute")]
    pub async fn execute(&self) -> Result<String> {
        use std::process::Command;
        use tempfile::NamedTempFile;
        use std::io::Write;
        use which::which;

        // Check if rust-script is available
        which("rust-script").map_err(|_| {
            TronError::ExecutionError("rust-script not found. Install with: cargo install rust-script".into())
        })?;

        // Render the template
        let rendered = self.template.render()?;
        
        // Create temporary file
        let mut temp_file = NamedTempFile::new()
            .map_err(|e| TronError::ExecutionError(format!("Failed to create temp file: {}", e)))?;
        
        // Build script content with dependencies
        let mut script_content = String::new();
        
        if !self.dependencies.is_empty() {
            script_content.push_str("//! ```cargo\n//! [dependencies]\n");
            for dep in &self.dependencies {
                script_content.push_str(&format!("//! {}\n", dep));
            }
            script_content.push_str("//! ```\n\n");
        }
        
        script_content.push_str(&rendered);

        // Write to temporary file
        temp_file.write_all(script_content.as_bytes())
            .map_err(|e| TronError::ExecutionError(format!("Failed to write temp file: {}", e)))?;

        // Execute with rust-script
        let output = Command::new("rust-script")
            .arg(temp_file.path())
            .output()
            .map_err(|e| TronError::ExecutionError(format!("Failed to execute script: {}", e)))?;

        if !output.status.success() {
            return Err(TronError::ExecutionError(
                String::from_utf8_lossy(&output.stderr).into_owned()
            ));
        }

        Ok(String::from_utf8_lossy(&output.stdout).into_owned())
    }

    /// Render the template to a string.
    ///
    /// This delegates to the inner template's [`render`](TronTemplate::render) method.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("Hello @[name]@!").unwrap();
    /// let mut template_ref = TronRef::new(template);
    /// template_ref.set("name", "World").unwrap();
    ///
    /// let result = template_ref.render().unwrap();
    /// assert_eq!(result, "Hello World!");
    /// ```
    pub fn render(&self) -> Result<String> {
        self.template.render()
    }

    /// Render the template with partial placeholder filling.
    ///
    /// This delegates to the inner template's [`render_partial`](TronTemplate::render_partial) method.
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("Hello @[greeting]@ @[name]@!").unwrap();
    /// let mut template_ref = TronRef::new(template);
    /// template_ref.set("greeting", "Hi").unwrap();
    ///
    /// let result = template_ref.render_partial().unwrap();
    /// assert_eq!(result, "Hello Hi @[name]@!");
    /// ```
    pub fn render_partial(&self) -> Result<String> {
        self.template.render_partial()
    }
}

impl From<TronTemplate> for TronRef {
    /// Convert a [`TronTemplate`] into a [`TronRef`].
    ///
    /// # Examples
    ///
    /// ```
    /// use tron::{TronTemplate, TronRef};
    ///
    /// let template = TronTemplate::new("Hello @[name]@!").unwrap();
    /// let template_ref: TronRef = template.into();
    /// ```
    fn from(template: TronTemplate) -> Self {
        Self::new(template)
    }
}

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

    #[test]
    fn test_new_template_ref() -> Result<()> {
        let template = TronTemplate::new("Hello @[name]@!")?;
        let template_ref = TronRef::new(template);
        
        assert!(template_ref.dependencies().is_empty());
        assert!(template_ref.inner().has_placeholder("name"));
        Ok(())
    }

    #[test]
    fn test_with_dependency() -> Result<()> {
        let template = TronTemplate::new("fn main() {}")?;
        let template_ref = TronRef::new(template)
            .with_dependency("serde = \"1.0\"");
            
        assert_eq!(template_ref.dependencies(), &["serde = \"1.0\""]);
        Ok(())
    }

    #[test]
    fn test_with_dependencies() -> Result<()> {
        let template = TronTemplate::new("fn main() {}")?;
        let template_ref = TronRef::new(template)
            .with_dependencies(&[
                "serde = \"1.0\"",
                "tokio = \"1.0\"",
            ]);
            
        assert_eq!(template_ref.dependencies().len(), 2);
        assert!(template_ref.dependencies().contains(&"serde = \"1.0\"".to_string()));
        assert!(template_ref.dependencies().contains(&"tokio = \"1.0\"".to_string()));
        Ok(())
    }

    #[test]
    fn test_add_dependency() -> Result<()> {
        let template = TronTemplate::new("fn main() {}")?;
        let mut template_ref = TronRef::new(template);
        template_ref.add_dependency("serde = \"1.0\"");
        
        assert_eq!(template_ref.dependencies(), &["serde = \"1.0\""]);
        Ok(())
    }

    #[test]
    fn test_clear_dependencies() -> Result<()> {
        let template = TronTemplate::new("fn main() {}")?;
        let mut template_ref = TronRef::new(template)
            .with_dependency("serde = \"1.0\"");
        
        template_ref.clear_dependencies();
        assert!(template_ref.dependencies().is_empty());
        Ok(())
    }

    #[test]
    fn test_set_and_render() -> Result<()> {
        let template = TronTemplate::new("Hello @[name]@!")?;
        let mut template_ref = TronRef::new(template);
        template_ref.set("name", "World")?;
        
        let result = template_ref.render()?;
        assert_eq!(result, "Hello World!");
        Ok(())
    }

    #[test]
    fn test_template_composition() -> Result<()> {
        // Create outer template
        let outer = TronTemplate::new("mod @[name]@ {\n    @[content]@\n}")?;
        let mut outer_ref = TronRef::new(outer);

        // Create inner template
        let inner = TronTemplate::new("fn @[func_name]@() {\n    @[body]@\n}")?;
        let mut inner_ref = TronRef::new(inner)
            .with_dependency("serde = \"1.0\"");

        inner_ref.set("func_name", "example")?;
        inner_ref.set("body", "println!(\"Hello!\");")?;

        // Compose templates
        outer_ref.set("name", "generated")?;
        outer_ref.set_ref("content", inner_ref)?;

        let result = outer_ref.render()?;
        assert!(result.contains("mod generated"));
        assert!(result.contains("fn example()"));
        assert!(result.contains("println!(\"Hello!\");"));
        
        // Check that dependencies were merged
        assert!(outer_ref.dependencies().contains(&"serde = \"1.0\"".to_string()));
        Ok(())
    }

    #[test]
    fn test_from_template() -> Result<()> {
        let template = TronTemplate::new("Hello @[name]@!")?;
        let template_ref: TronRef = template.into();
        
        assert!(template_ref.inner().has_placeholder("name"));
        Ok(())
    }

    #[test]
    fn test_render_partial() -> Result<()> {
        let template = TronTemplate::new("@[greeting]@ @[name]@!")?;
        let mut template_ref = TronRef::new(template);
        template_ref.set("greeting", "Hello")?;
        
        let result = template_ref.render_partial()?;
        assert_eq!(result, "Hello @[name]@!");
        Ok(())
    }
}