pub mod attributes;
pub mod error;

use tera::{Context, Tera};

use attributes::AttributesMap;
use error::Error;

pub struct Pete {

}

impl Pete {
    pub fn new() -> Pete {
        Pete {

        }
    }

    pub fn render<S: Into<String>>(&self, template: S, attributes: &AttributesMap) -> Result<String, Error> {
        let template_string = template.into();
        let mut tera = Tera::default();

        match tera.add_raw_template("<input>", template_string.as_str()) {
            Ok(_) => Ok(()),
            Err(e) => Err(Error::new(&format!("{}", e))),
        }?;

        let mut context = Context::new();
        for (key, value) in attributes.iter() {
            context.insert(key, value);
        }

        match tera.render("<input>", &context) {
            Ok(s) => Ok(s),
            Err(e) => Err(Error::new(&format!("{}", e))),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use attributes::{AttributesMap, insert_attribute};

    #[test]
    fn render_static() {
        let engine = Pete::new();
        match engine.render("Hello!", &AttributesMap::new()) {
            Ok(r) => assert_eq!("Hello!", r),
            Err(e) => panic!("{}", e),
        }
    }

    #[test]
    fn render_var() {
        let engine = Pete::new();
        let mut attrs = AttributesMap::new();
        insert_attribute(&mut attrs, "greeting", "Hello");

        let mut user = AttributesMap::new();
        insert_attribute(&mut user, "first_name", "John");
        insert_attribute(&mut user, "last_name", "Doe");
        insert_attribute(&mut user, "age", 24);
        insert_attribute(&mut attrs, "user", user);

        match engine.render("{{ greeting }}, {{ user.first_name }} {{ user.last_name }}! Your age is {{ user.age }}.", &attrs) {
            Ok(r) => assert_eq!("Hello, John Doe! Your age is 24.", r),
            Err(e) => panic!("{}", e),
        }
    }

    #[test]
    fn render_error() {
        let engine = Pete::new();
        match engine.render("Hello! {% not closed", &AttributesMap::new()) {
            Ok(_) => panic!("An error is expected to be thrown"),
            Err(e) => assert_eq!(format!("{}", e), "Failed to parse '<input>'"),
        }
    }
}