/*!
A minimal templating engine that renders a string from the template, replacing all instances of `{placeholder}` with given values.

The engine is strict:

* all placeholders must have values provided (use [template_default] to use default value for placeholders),
* all provided values must have matching placeholder (when using [template_strict]),
* a single placeholder can be used multiple times and will be expanded in all places.

Values are provided as an iterable object that provides placeholder name and value pairs.

Placeholder name may only contain letters (`a` to `z`, `A` to `Z`), numbers, dash, underscore and a dot to limit the risk of accidental placeholders in templates.

Hash maps are not used; all data is kept in vectors making it `O(N + N * M)` where `N` is number of placeholders and `M` is number of values. This should still be very fast for templates with small number of placeholders as no data is copied (works with slices).

```rust
use nanotemplate::template;

assert_eq!(
    template("Hello, my name is {name}!", &[("name", "nanotemplate")]).unwrap(),
    "Hello, my name is nanotemplate!".to_owned());
```

Also comes with simple CLI utility:

```sh
echo "Hello, my name is {name}!" | nanotemplate name=nanotemplate
```

*/

use std::error::Error;
use std::fmt::{self, Display, Write};

#[derive(Debug)]
pub enum TemplateError {
    MissingValueForPlaceholder(String),
    NoPlaceholder(String),
    OutputError(fmt::Error),
}

impl Display for TemplateError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TemplateError::MissingValueForPlaceholder(placeh) => write!(f, "template is missing value for placeholder {:?}", placeh),
            TemplateError::NoPlaceholder(placeh) => write!(f, "template has no placeholder {:?}", placeh),
            TemplateError::OutputError(_) => write!(f, "failed to write to output"),
        }
    }
}

impl Error for TemplateError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            TemplateError::MissingValueForPlaceholder(_) => None,
            TemplateError::NoPlaceholder(_) => None,
            TemplateError::OutputError(err) => Some(err),
        }
    }
}

impl From<fmt::Error> for TemplateError {
    fn from(err: fmt::Error) -> TemplateError {
        TemplateError::OutputError(err)
    }
}

/// Provides a way to get placeholder name and value for template expansion.
pub trait PlaceholderValuePair<'v, V: ?Sized> {
    /// The name of the placeholder to match in the template.
    fn placeholder(&self) -> &str;
    /// Reference to the value to replace the template placeholders with.
    fn value_ref(&self) -> &'v V;
}

impl<'k, 'v, V: ?Sized, P: PlaceholderValuePair<'v, V>> PlaceholderValuePair<'v, V> for &P {
    fn placeholder(&self) -> &str {
        (*self).placeholder()
    }

    fn value_ref(&self) -> &'v V {
        (*self).value_ref()
    }
}

impl<'v, K: AsRef<str>, V: ?Sized> PlaceholderValuePair<'v, V> for (K, &'v V) {
    fn placeholder(&self) -> &str {
        self.0.as_ref()
    }

    fn value_ref(&self) -> &'v V {
        self.1
    }
}

impl<'t> PlaceholderValuePair<'t, str> for [&'t str; 2] {
    fn placeholder(&self) -> &str {
        self[0]
    }

    fn value_ref(&self) -> &'t str {
        self[1]
    }
}

fn alloc_out_string(template: &str) -> String {
    String::with_capacity(template.len())
}

/// Renders a string from the template, replacing all instances of `{placeholder}` with given values.
///
/// Placeholder name may only contain letters, numbers, dash, underscore and a dot.
pub fn template<'v, T: PlaceholderValuePair<'v, impl Display + ?Sized + 'v>>(
    template: &str, values: impl IntoIterator<Item = T>
) -> Result<String, TemplateError> {
    let mut out = alloc_out_string(template);
    template_base(&mut out, template, values, false, None)?;
    Ok(out)
}

/// Variant of [template()] that write outputs to `out`.
pub fn write_template<'v, T: PlaceholderValuePair<'v, impl Display + ?Sized + 'v>>(
    mut out: impl Write, template: &str, values: impl IntoIterator<Item = T>
) -> Result<(), TemplateError> {
    template_base(&mut out, template, values, false, None)
}

/// Renders a string from the template, replacing all instances of `{placeholder}` with given values.
///
/// Placeholder name may only contain letters, numbers, dash, underscore and a dot.
///
/// It is an error to pass values for non-existing placeholders.
pub fn template_strict<'v, T: PlaceholderValuePair<'v, impl Display + ?Sized + 'v>>(
    template: &str, values: impl IntoIterator<Item = T>
) -> Result<String, TemplateError> {
    let mut out = alloc_out_string(template);
    template_base(&mut out, template, values, true, None)?;
    Ok(out)
}

/// Variant of [template_strict()] that writes output to `out`.
pub fn write_template_strict<'v, T: PlaceholderValuePair<'v, impl Display + ?Sized + 'v>>(
    mut out: impl Write, template: &str, values: impl IntoIterator<Item = T>
) -> Result<(), TemplateError> {
    template_base(&mut out, template, values, true, None)
}

/// Renders a string from the template, replacing all instances of `{placeholder}` with given values.
///
/// Placeholder name may only contain letters, numbers, dash, underscore and a dot.
///
/// Default value is used for missing placeholder values.
pub fn template_default<'v, T: PlaceholderValuePair<'v, impl Display + ?Sized + 'v>>(
    template: &str, values: impl IntoIterator<Item = T>, default: &str
) -> Result<String, TemplateError> {
    let mut out = alloc_out_string(template);
    template_base(&mut out, template, values, false, Some(default))?;
    Ok(out)
}

/// Variant of [template_default()] that writes output to `out`.
pub fn write_template_default<'v, T: PlaceholderValuePair<'v, impl Display + ?Sized + 'v>>(
    mut out: impl Write, template: &str, values: impl IntoIterator<Item = T>, default: &str
) -> Result<(), TemplateError> {
    template_base(&mut out, template, values, false, Some(default))
}

fn template_base<'v, T: PlaceholderValuePair<'v, impl Display + 'v + ?Sized>>(
    mut out: impl Write,
    template: &str,
    values: impl IntoIterator<Item = T>,
    strict_values: bool,
    default: Option<&str>,
) -> Result<(), TemplateError> {
    let mut vars = Vec::new();
    let mut slices = Vec::new();

    let mut from = 0;
    let mut candidate = None;

    for (i, c) in template.char_indices() {
        match c {
            '{' => candidate = Some(i),
            '}' => if let Some(placeh) = candidate.take() {
                slices.push(&template[from .. placeh]);
                vars.push((&template[placeh + 1 .. i], None));
                from = i + 1;
            }
            c => match c {
                'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' | '.' => (),
                _ => candidate = None,
            }
        }
    }

    slices.push(&template[from .. template.len()]);

    for t in values {
        let tplaceh = t.placeholder();
        let tvalue = t.value_ref();
        let mut found = false;

        for &mut (placeh, ref mut value) in vars.iter_mut() {
            if placeh == tplaceh {
                *value = Some(tvalue);
                found = true;
            }
        }

        if strict_values && !found {
            return Err(TemplateError::NoPlaceholder(tplaceh.to_owned()))
        }
    }

    let len = slices.len();

    for (i, s) in slices.into_iter().enumerate() {
        out.write_str(s)?;

        if i < len - 1 {
            let slot = &vars[i];
            match &slot.1 {
                Some(ph) => { write!(out, "{}", ph).unwrap(); },
                None => if let Some(default) = default.as_ref() {
                    out.write_str(default)?
                } else {
                    return Err(TemplateError::MissingValueForPlaceholder(slot.0.to_owned()))
                }
            }
        }
    }
    
    Ok(())
}

#[cfg(test)]
mod tests {
    use std::collections::HashMap;

    use super::*;

    #[test]
    fn test_template_empty() {
        assert_eq!(&template::<&(&str, &str)>("", None).unwrap(), "");
    }

    #[test]
    fn test_template_none() {
        assert_eq!(&template::<&(&str, &str)>("hello world", None).unwrap(), "hello world");
    }

    #[test]
    fn test_template_single() {
        assert_eq!(&template("hello {foo} world", Some(("foo", "bar"))).unwrap(), "hello bar world");
    }

    #[test]
    fn test_template_single_variable_multi() {
        assert_eq!(&template("{foo} hello {foo} world {foo}", Some(("foo", "bar"))).unwrap(), "bar hello bar world bar");
    }

    #[test]
    fn test_template_many_vars_slice() {
        assert_eq!(&template("{foo} hello {bar} world {baz}", &[("foo", "1"), ("bar", "2"), ("baz" ,"3")]).unwrap(), "1 hello 2 world 3");
    }

    #[test]
    fn test_template_many_vars_slice_int() {
        assert_eq!(&template("{foo} hello {bar} world {baz}", &[("foo", &1), ("bar", &2), ("baz" ,&3)]).unwrap(), "1 hello 2 world 3");
    }

    #[test]
    fn test_template_many_vars_slice_string_refs() {
        assert_eq!(&template("{foo} hello {bar} world {baz}", &[("foo", &"1".to_string()), ("bar", &"2".to_string()), ("baz" ,&"3".to_string())]).unwrap(), "1 hello 2 world 3");
    }

    #[test]
    fn test_template_many_placeholder_strings() {
        assert_eq!(&template("{foo} hello {bar} world {baz}", &[("foo".to_owned(), "1"), ("bar".to_owned(), "2"), ("baz".to_owned() ,"3")]).unwrap(), "1 hello 2 world 3");
    }

    #[test]
    fn test_template_many_vars_slice_array() {
        assert_eq!(&template("{foo} hello {bar} world {baz}", &[["foo", "1"], ["bar", "2"], ["baz" ,"3"]]).unwrap(), "1 hello 2 world 3");
    }

    #[test]
    fn test_template_many_vars_vec() {
        assert_eq!(&template("{foo} hello {bar} world {baz}", vec![("foo", "1"), ("bar", "2"), ("baz" ,"3")]).unwrap(), "1 hello 2 world 3");
    }

    #[test]
    fn test_template_many_vars_hash_map() {
        let mut map = HashMap::new();
        map.insert("foo", "1");
        map.insert("bar", "2");
        map.insert("baz", "3");
        assert_eq!(&template("{foo} hello {bar} world {baz}", map).unwrap(), "1 hello 2 world 3");
    }

    #[test]
    fn test_template_nested_reverse() {
        assert_eq!(&template("}}}{foo}{{ hello }}}{bar}{{{ world }}{baz}{{{", vec![("foo", "1"), ("bar", "2"), ("baz" ,"3")]).unwrap(), "}}}1{{ hello }}}2{{{ world }}3{{{");
    }

    #[test]
    fn test_template_nested() {
        assert_eq!(&template("{{{{foo}}} hello {{{{bar}}}} world {{{baz}}}}", vec![("foo", "1"), ("bar", "2"), ("baz" ,"3")]).unwrap(), "{{{1}} hello {{{2}}} world {{3}}}");
    }

    #[test]
    fn test_template_json() {
        let tpl = r#"{"menu": {
  "id": "file",
  "value": {File},
  "{Popup}": {
    "menuitem": [
      {"value": "{New}", "onclick": "CreateNewDoc()"},
      {"value": "{Open}", "onclick": "OpenDoc()"},
      {"value": "{Close}", "onclick": "CloseDoc()"}
    ]
  }
}}"#;

        let out = r#"{"menu": {
  "id": "file",
  "value": "File",
  "popup": {
    "menuitem": [
      {"value": "New", "onclick": "CreateNewDoc()"},
      {"value": "Open", "onclick": "OpenDoc()"},
      {"value": "Close", "onclick": "CloseDoc()"}
    ]
  }
}}"#;

        assert_eq!(&template(tpl, vec![("File", "\"File\""), ("Popup", "popup"), ("New", "New"), ("Open" ,"Open"), ("Close", "Close")]).unwrap(), out);
    }

    #[test]
    fn test_template_many_vars_space() {
        assert_eq!(&template("{foo} hello {foo bar} world {baz}", vec![("foo", "1"), ("baz" ,"3")]).unwrap(), "1 hello {foo bar} world 3");
        assert_eq!(&template("{foo.bar} hello {foo+bar} world {foo_baz}", vec![("foo.bar", "1"), ("foo_baz" ,"3")]).unwrap(), "1 hello {foo+bar} world 3");
    }

    #[test]
    fn test_template_missing_placeholder_default() {
        assert_eq!(&template_default::<&(&str, &str)>("{foo} hello {foo} world {foo}", &[], "bar").unwrap(), "bar hello bar world bar");
    }

    #[test]
    #[should_panic(expected = "template is missing value for placeholder \\\"foo\\\"")]
    fn test_template_missing_placeholder() {
        template::<&(&str, &str)>("{foo} hello {foo} world {foo}", &[]).map_err(|e| e.to_string()).unwrap();
    }

    #[test]
    fn test_template_no_placeholder() {
        assert_eq!(&template("{foo} hello {foo} world {foo}", vec![("foo", "1"), ("bar", "2")]).unwrap(), "1 hello 1 world 1");
    }

    #[test]
    #[should_panic(expected = "template has no placeholder \\\"bar\\\"")]
    fn test_template_no_placeholder_strict() {
        template_strict("{foo} hello {foo} world {foo}", vec![("foo", "1"), ("bar", "2")]).map_err(|e| e.to_string()).unwrap();
    }
}