use std::path::PathBuf;
use std::error::Error as STDError;

use options::NewOps;
use logger::{LogLevel, Logger};
use file_writer;
use error::Error;
use config_toml::{PageConfig, PageConfigToml};

use toml;
use pathdiff;

const PLACEHOLDER_MARKDOWN: &'static str = 
r#"# Placeholder title
This is the markdown file, where you will insert this page's contents.
- This is an example list
- And in lists
  - You can even make inner lists, as well as **bold**, and _italics_
  
See [CommonMark](http://commonmark.org/help/) for reference."#;

pub fn generate_new_page(ops: NewOps, logger: &Logger) -> Result<(), Error> {
    logger.log(
        LogLevel::DETAILER,
        format!("Starting to create paths for given files"),
    );

    let toml_path = ensure_extension(ops.toml_path, "toml", false)?;

    let markdown_path;
    if let Some(markdown) = ops.markdown_path {
        markdown_path = ensure_extension(markdown, "md", false)?;
    } else {
        markdown_path = ensure_extension(toml_path.clone(), "md", true)?;
    }

    logger.log(
        LogLevel::DETAIL,
        format!("Creating a new .toml file at {:?}", toml_path),
    );

    let html_path;
    if let Some(path) = ops.html_path {
        html_path = ensure_extension(path, "html", false)?;
    } else {
        html_path = ensure_extension(toml_path.clone(), "html", true)?;
    }

    let title: String;
    if let Some(t) = ops.title {
        title = t;
    } else {
        let mut parts = toml_path.file_name().unwrap().to_str().unwrap().split(".");
        title = parts.next().unwrap().to_owned();
    }

    let mut relative_markdown_path = markdown_path.clone();
    if let Some(toml_parent) = toml_path.parent() {
        if let Some(relative) = pathdiff::diff_paths(markdown_path.as_path(), toml_parent) {
            relative_markdown_path = relative;
        }
    }

    let page_config = PageConfigToml {
        page: PageConfig {
            html_path: html_path.to_str().unwrap().to_owned(),
            title: title,
            description: String::new(),
            content_path: relative_markdown_path.to_str().unwrap().to_owned(),
            favicon: None,
            before_navbar_url: None,
            before_content_url: None,
            after_content_url: None,
            javascript: None,
            css: None,
        },
    };

    match toml::ser::to_string_pretty(&page_config) {
        Ok(text) => file_writer::write_file(toml_path.clone(), text, ops.overwrite)?,
        Err(err) => {
            return Err(Error::new(
                LogLevel::SEVERE,
                format!(
                    "Failed to serialize page config: {}",
                    err.description().to_owned()
                ),
            ))
        }
    }

    logger.log(
        LogLevel::DETAIL,
        format!("Creating a new .md file at {:?}", markdown_path),
    );

    file_writer::write_file(markdown_path, PLACEHOLDER_MARKDOWN, ops.overwrite)?;

    Ok(())
}

fn ensure_extension<T: Into<String>>(
    mut path: PathBuf,
    extension: T,
    replace_extension: bool,
) -> Result<PathBuf, Error> {
    let extension = extension.into();

    if let (Some(parent), Some(file_name)) = (path.clone().parent(), path.clone().file_name()) {
        let mut filename = file_name.to_str().unwrap().to_owned();
        let clone = filename.clone();
        let mut split = clone.split(".");
        if split.clone().count() == 1 as usize {
            path = parent.join(format!("{}.{}", filename, extension));
        } else if replace_extension {
            let amount = split.clone().count() - 1;
            filename = split
                .clone()
                .take(amount)
                .map(|i| format!("{}.", i))
                .collect::<String>();

            path = parent.join(format!("{}{}", filename, extension));
        }

        Ok(path)
    } else {
        Err(Error::new(
            LogLevel::SEVERE,
            format!("Could not find parent/file_name for {:?}", path),
        ))
    }
}