use config_toml::{GlobalConfigToml, PageConfigToml};
use std::path::PathBuf;
use error::Error;
use logger::LogLevel;

#[derive(Clone)]
pub struct SinglePageConfigs {
    pub global_config: GlobalConfigToml,
    pub page_config: PageConfigToml,
    pub page_config_path: PathBuf,
}

#[derive(Debug)]
pub struct Config {
    pub global_config: GlobalConfigToml,
    pub page_config_paths: Vec<PathBuf>,
    pub page_configs: Vec<PageConfigToml>,
}

impl Config {
    pub fn new() -> Result<Config, Error> {
        let global_config = GlobalConfigToml::get_config()?;
        let mut page_configs = Vec::new();
        let mut page_config_paths = Vec::new();
        for page_config in global_config.clone().website.built_pages {
            let path = PathBuf::from(page_config);
            let config = PageConfigToml::get_from(&path)?;
            page_configs.push(config);
            page_config_paths.push(path);
        }
        Ok(Config {
            global_config,
            page_config_paths,
            page_configs,
        })
    }

    pub fn get_configs_for(&self, idx: u32) -> Result<SinglePageConfigs, Error> {
        if let (Some(page_config), Some(page_path)) = (
            self.page_configs.get(idx as usize),
            self.page_config_paths.get(idx as usize),
        ) {
            Ok(SinglePageConfigs {
                global_config: self.global_config.clone(),
                page_config: page_config.clone(),
                page_config_path: page_path.clone(),
            })
        } else {
            Err(Error::new(
                LogLevel::SEVERE,
                format!("Failed to get page config, idx: {}", idx),
            ))
        }
    }

    pub fn get_configs(&self) -> Result<Vec<SinglePageConfigs>, Error> {
        let mut configs = Vec::new();
        for idx in 0..self.page_configs.len() {
            let config = self.get_configs_for(idx as u32)?;
            configs.push(config);
        }
        Ok(configs)
    }
}