use crate::{error::Result, site::Site, template::Template};
use serde::Serialize;
use serde_json::json;
use std::collections::{HashMap, HashSet};

#[derive(Serialize, Default)]
pub struct Article {
    filename: String,
    date: String,
    author: String,
    properties: HashMap<String, String>,
    tags: HashSet<String>,
}

#[derive(Serialize, Default)]
pub struct ArticleContext {
    article: Article,
    content: String,
}

impl ArticleContext {
    pub fn load(article: Article) -> Result<Self> {
        Ok(Self {
            article,
            content: String::new(),
        })
    }

    #[cfg(test)]
    pub fn load_string(article: Article, content: &str) -> Result<Self> {
        Ok(Self {
            article,
            content: content.to_string(),
        })
    }
}

pub fn generate_article(
    site: &Site,
    article: &ArticleContext,
    template: &Template,
) -> Result<String> {
    let ctx = json!({
        "site": site,
        "data": article,
    });
    let res = template.generate(&ctx)?;
    Ok(res)
}

#[cfg(test)]
mod tests {
    use crate::template::Template;

    use super::*;

    pub fn fixture_article() -> Article {
        Article {
            filename: "test.org".to_string(),
            date: "".to_string(),
            author: "Bob Bobberson".to_string(),
            properties: HashMap::new(),
            tags: vec!["article", "new", "cool"]
                .into_iter()
                .map(String::from)
                .collect(),
        }
    }

    #[test]
    fn test_generate() {
        let article_ctx =
            ArticleContext::load_string(fixture_article(), "ten animals i slam in a net")
                .expect("couldnt build article");
        let template =
            Template::new("content: {{{data.content}}}, site: {{site.title}}".to_string());
        let site = crate::site::tests::fixture_site();
        let res =
            generate_article(&site, &article_ctx, &template).expect("couldnt gnenerate template");

        assert_eq!(res, "content: ten animals i slam in a net, site: Test Site");
    }
}