femstache 0.1.8

use std::collections::BTreeMap;

use femstache_eval::{
    EvalError, EvalResult, StringValue, TemplateEnv, TemplateInput, Value, eval_expr,
};
use femstache_loader::{LoaderError, TemplateLoader};
use femstache_parser::nodes::{
    Control, Document, DocumentNode, DocumentNodes, ForControlExpr, Stache,
};

use crate::output::Output;

pub struct TemplateRenderer<'i, I: TemplateInput> {
    env: TemplateEnv<'i, I>,
    blocks: BTreeMap<String, String>,
    loader: Option<TemplateLoader>,
}

impl<'i, I: TemplateInput> TemplateRenderer<'i, I> {
    pub fn new(
        env: TemplateEnv<'i, I>,
        blocks: BTreeMap<String, String>,
        loader: Option<TemplateLoader>,
    ) -> Self {
        Self {
            env,
            blocks,
            loader,
        }
    }

    pub fn render_document(&mut self, document: &Document, output: &mut Output) -> EvalResult<()> {
        if let Some(meta) = &document.meta
            && let Some(inherit) = &meta.inherit
        {
            if let Some(loader) = self.loader.as_mut() {
                let template = loader.load(inherit.path.as_str())?;
                self.env.push();
                self.render_document_nodes(&document.nodes, &mut Output::null(output.escape()))?;
                self.env.pop();
                self.env.push();
                self.render_document(template.document(), output)?;
                self.env.pop();
            } else {
                return Err(EvalError::Loader(LoaderError::NoLoader));
            }
        } else {
            self.render_document_nodes(&document.nodes, output)?;
        }
        Ok(())
    }

    pub fn render_document_nodes(
        &mut self,
        nodes: &DocumentNodes,
        output: &mut Output,
    ) -> EvalResult<()> {
        for node in &nodes.nodes {
            self.render_document_node(node, output)?;
        }
        Ok(())
    }

    pub fn render_document_node(
        &mut self,
        node: &DocumentNode,
        output: &mut Output,
    ) -> EvalResult<()> {
        match node {
            DocumentNode::Output(o) => {
                output.push(&o.data);
                Ok(())
            }
            DocumentNode::Stache(s) => self.render_stache(s, output),
            DocumentNode::Control(c) => self.render_control(c, output),
        }
    }

    pub fn render_stache(&mut self, stache: &Stache, output: &mut Output) -> EvalResult<()> {
        let val = eval_expr(&self.env, &stache.expr)?;
        let s = val.as_string().ok_or(EvalError::InvalidType)?;
        match s {
            StringValue::Regular(s) => output.push_escaped(s),
            StringValue::Raw(s) => output.push(s),
        }
        Ok(())
    }

    pub fn render_control(&mut self, control: &Control, output: &mut Output) -> EvalResult<()> {
        match control {
            Control::IfControl(if_control) => {
                let cond = eval_expr(&self.env, &if_control.open.cond)?;
                if cond.is_truthy() {
                    self.env.push();
                    self.render_document_nodes(&if_control.inner, output)?;
                    self.env.pop();
                }
            }
            Control::ForControl(for_control) => match &for_control.open.expr {
                ForControlExpr::List(l) => {
                    let value = eval_expr(&self.env, &l.expr)?;
                    let list = value.into_list().ok_or(EvalError::InvalidType)?;
                    for item in list {
                        self.env.push();
                        self.env.set(&for_control.open.var.data, item);
                        self.render_document_nodes(&for_control.inner, output)?;
                        self.env.pop();
                    }
                }
                ForControlExpr::Dict(d) => {
                    let value = eval_expr(&self.env, &d.expr)?;
                    let dict = value.into_dict().ok_or(EvalError::InvalidType)?;
                    for (key, val) in dict {
                        self.env.push();
                        let mut map = BTreeMap::new();
                        map.insert("key".to_owned(), Value::string(key));
                        map.insert("val".to_owned(), val);
                        self.env.set(&for_control.open.var.data, Value::Struct(map));
                        self.render_document_nodes(&for_control.inner, output)?;
                        self.env.pop();
                    }
                }
            },
            Control::BlockControl(block_control) => {
                self.env.push();
                if let Some(block) = self.blocks.get(block_control.open.name.as_str()) {
                    output.push(block);
                } else {
                    let key = block_control.open.name.as_str().to_owned();
                    let mut block = Output::string(output.escape());
                    self.env.push();
                    self.render_document_nodes(&block_control.inner, &mut block)?;
                    let block = block.into_inner();
                    output.push(&block);
                    self.blocks.insert(key, block);
                    self.env.pop();
                }
                self.env.pop();
            }
            Control::IncludeControl(include_control) => {
                if let Some(loader) = self.loader.as_mut() {
                    let template = loader.load(include_control.path.as_str())?;
                    self.env.push();
                    self.render_document(template.document(), output)?;
                    self.env.pop();
                } else {
                    return Err(EvalError::Loader(LoaderError::NoLoader));
                }
            }
            Control::LetControl(let_control) => {
                let value = eval_expr(&self.env, &let_control.expr)?;
                self.env.set(&let_control.var.data, value);
            }
        }
        Ok(())
    }
}