use std::fs::File;
use std::io::Read;
use std::path::PathBuf;
use std::error::Error as STDError;

use pulldown_cmark::{html, Parser};

use config::{Config, SinglePageConfigs};
use template::Template;
use error::Error;
use logger::{LogLevel, Logger};

fn get_file_contents(path: Option<String>) -> Result<String, Error> {
    match path {
        Some(url) => match File::open(PathBuf::from(&url)) {
            Ok(mut file) => {
                let mut content = String::new();
                file.read_to_string(&mut content).unwrap();
                Ok(content)
            }
            Err(err) => Err(Error::new(
                LogLevel::WARNING,
                format!("Failed to open {}, {}", url, err.description().to_owned()),
            )),
        },
        None => Ok(String::new()),
    }
}

pub fn render_injections(
    logger: &Logger,
    config: &SinglePageConfigs,
) -> Result<(String, String, String), Error> {
    let before_navbar_url = match config.page_config.page.before_navbar_url.clone() {
        Some(url) => Some(url),
        None => config.global_config.website.before_navbar_url.clone(),
    };
    let before_content_url = match config.page_config.page.before_content_url.clone() {
        Some(url) => Some(url),
        None => config.global_config.website.before_content_url.clone(),
    };
    let after_content_url = match config.page_config.page.after_content_url.clone() {
        Some(url) => Some(url),
        None => config.global_config.website.after_content_url.clone(),
    };

    let before_navbar = match get_file_contents(before_navbar_url) {
        Ok(content) => content,
        Err(error) => {
            logger.log(error.severity(), error.description());
            String::new()
        }
    };
    let before_content = match get_file_contents(before_content_url) {
        Ok(content) => content,
        Err(error) => {
            logger.log(error.severity(), error.description());
            String::new()
        }
    };
    let after_content = match get_file_contents(after_content_url) {
        Ok(content) => content,
        Err(error) => {
            logger.log(error.severity(), error.description());
            String::new()
        }
    };

    Ok((before_navbar, before_content, after_content))
}

pub fn render_markdown_content(config: &SinglePageConfigs) -> Result<String, Error> {
    if let Some(parent) = config.page_config_path.parent() {
        let path = parent.join(&config.page_config.page.content_path);
        match File::open(&path) {
            Ok(mut file) => {
                let mut content = String::new();
                file.read_to_string(&mut content).ok();
                let parser = Parser::new(&content);

                let mut markdown = String::new();
                html::push_html(&mut markdown, parser);
                Ok(markdown)
            }
            Err(_) => Err(Error::new(
                LogLevel::SEVERE,
                format!("Failed to open file: {}", path.to_str().unwrap()),
            )),
        }
    } else {
        Err(Error::new(
            LogLevel::SEVERE,
            format!(
                "Failed to get page config parent: {}",
                config.page_config_path.to_str().unwrap()
            ),
        ))
    }
}

pub fn render_navbar(
    config: &Config,
    item_template: Template,
    image_item_template: Template,
) -> Result<String, Error> {
    let mut navbar_str = String::new();

    if let Some(navbar) = config.global_config.navbar.clone() {
        for item_str in navbar.items {
            if let Some(item) = navbar.item_map.get(&item_str) {
                let data = Template::navbar_item_data_from(item.clone());
                if item.image_url.is_some() {
                    navbar_str += &*image_item_template.render(&data);
                } else {
                    navbar_str += &*item_template.render(&data);
                }
            } else {
                return Err(Error::new(
                    LogLevel::SEVERE,
                    format!("Navbar item does not exist: navbar.item.{}", item_str),
                ));
            }
        }
        Ok(navbar_str)
    } else {
        Err(Error::new(
            LogLevel::SEVERE,
            "Attempted to render navbar without navbar".to_owned(),
        ))
    }
}