natter/src/context/blog_stream.rs

use std::path::Path;

use serde::Serialize;

use crate::config::Config;
use crate::context::RenderDocumentElement;
use crate::context::RenderRealFootnoteDefinition;
use crate::error::CustomError;
use crate::intermediate::get_web_path;
use crate::intermediate::BlogPost;

use super::GlobalSettings;
use super::PageHeader;

#[derive(Debug, Serialize)]
#[serde(tag = "type")]
#[serde(rename = "blog_stream")]
pub(crate) struct RenderBlogStream {
    global_settings: GlobalSettings,
    page_header: Option<PageHeader>,
    children: Vec<RenderBlogStreamEntry>,
    stream_pagination: Option<RenderBlogStreamPagination>,
}

impl RenderBlogStream {
    pub(crate) fn new(
        config: &Config,
        output_directory: &Path,
        output_file: &Path,
        original: &[&BlogPost],
        older_link: Option<String>,
        newer_link: Option<String>,
    ) -> Result<RenderBlogStream, CustomError> {
        let css_files = vec![
            // get_web_path(
            //     config,
            //     output_directory,
            //     output_file,
            //     "stylesheet/reset.css",
            // )?,
            get_web_path(config, output_directory, output_file, "stylesheet/main.css")?,
        ];
        let js_files = vec![get_web_path(
            config,
            output_directory,
            output_file,
            "blog_post.js",
        )?];
        let global_settings = GlobalSettings::new(
            config.get_site_title().map(str::to_string),
            css_files,
            js_files,
        );
        let page_header = PageHeader::new(
            config.get_site_title().map(str::to_string),
            Some(get_web_path(config, output_directory, output_file, "")?),
        );

        let children = original
            .into_iter()
            .map(|blog_post| {
                RenderBlogStreamEntry::new(config, output_directory, output_file, blog_post)
            })
            .collect::<Result<Vec<_>, _>>()?;

        let stream_pagination = if older_link.is_some() || newer_link.is_some() {
            Some(RenderBlogStreamPagination::new(older_link, newer_link)?)
        } else {
            None
        };

        Ok(RenderBlogStream {
            global_settings,
            page_header: Some(page_header),
            children,
            stream_pagination,
        })
    }
}

#[derive(Debug, Serialize)]
pub(crate) struct RenderBlogStreamEntry {
    /// The title that will be shown visibly on the page.
    title: Option<String>,

    self_link: Option<String>,

    children: Vec<RenderDocumentElement>,

    footnotes: Vec<RenderRealFootnoteDefinition>,
}

impl RenderBlogStreamEntry {
    fn new(
        config: &Config,
        output_directory: &Path,
        output_file: &Path,
        original: &BlogPost,
    ) -> Result<RenderBlogStreamEntry, CustomError> {
        // TODO: This link is probably wrong.
        let link_to_blog_post = get_web_path(
            config,
            output_directory,
            output_file,
            output_file.strip_prefix(output_directory)?,
        )?;

        // TODO: Should I guess an index page instead of erroring out?
        let index_page = original
            .get_index_page()
            .ok_or_else(|| format!("Blog post {} needs an index page.", original.id))?;

        let title = index_page.title.clone();

        // TODO: Handle footnotes.
        let children = index_page
            .children
            .iter()
            .map(|child| RenderDocumentElement::new(config, output_directory, output_file, child))
            .collect::<Result<Vec<_>, _>>()?;

        Ok(RenderBlogStreamEntry {
            title,
            self_link: Some(link_to_blog_post),
            children,
            footnotes: Vec::new(),
        })
    }
}

#[derive(Debug, Serialize)]
pub(crate) struct RenderBlogStreamPagination {
    older_link: Option<String>,
    newer_link: Option<String>,
}

impl RenderBlogStreamPagination {
    fn new(
        older_link: Option<String>,
        newer_link: Option<String>,
    ) -> Result<RenderBlogStreamPagination, CustomError> {
        Ok(RenderBlogStreamPagination {
            older_link,
            newer_link,
        })
    }
}