use std::path::PathBuf;

    pub template: Option<Templates>,

}
#[derive(Debug, Serialize, Deserialize)]
pub struct Templates {
    pub message: Option<PathBuf>,
    pub description: Option<PathBuf>,

            self.header()

            self.header()?

    fn header(&self) -> ChangeHeader {

    fn header(&self) -> Result<ChangeHeader, anyhow::Error> {
        let config = crate::config::Global::load();

        } else if let Ok(global) = crate::config::Global::load() {
            vec![global.author]

        } else if let Ok(global) = config.as_ref() {
            vec![global.author.clone()]

        ChangeHeader {
            message: self.message.clone().unwrap_or_else(String::new),

        let templates = config.as_ref().ok().and_then(|cfg| cfg.template.as_ref());
        let message = if let Some(message) = &self.message {
            message.clone()
        } else if let Some(message_file) = templates.and_then(|t| t.message.as_ref()) {
            match std::fs::read_to_string(message_file) {
                Ok(m) => m,
                Err(e) => bail!("Could not read message template: {:?}: {}", message_file, e),
            }
        } else {
            String::new()
        };
        let description = if let Some(descr_file) = templates.and_then(|t| t.description.as_ref()) {
            match std::fs::read_to_string(descr_file) {
                Ok(d) => Some(d),
                Err(e) => bail!(
                    "Could not read description template: {:?}: {}",
                    descr_file,
                    e
                ),
            }
        } else {
            None
        };
        let header = ChangeHeader {
            message,

            description: None,

            description,

        }

        };
        Ok(header)