extern crate ansi_term;
extern crate pathdiff;
extern crate pulldown_cmark;
extern crate regex;
extern crate serde;
#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate structopt;
extern crate toml;

mod logger;
mod options;
mod error;
mod config_toml;
mod config;
mod template;
mod renderer;
mod builder;
mod new_page;
mod file_writer;

use std::collections::HashMap;
use std::path::PathBuf;
use std::process::exit;

use structopt::StructOpt;

use logger::{LogLevel, Logger};
use options::{Opt, Subcommands};
use config_toml::{GlobalConfigToml, NavbarConfig, NavbarItem, WebsiteConfig};

//TODO: Custom markdown
fn main() {
    exit(match run() {
        Ok(()) => 0,
        Err(()) => 1,
    })
}

fn run() -> Result<(), ()> {
    let opt = Opt::from_args();

    let log_level = (3 - opt.quiet as i8 + opt.verbose as i8).max(0).min(5);
    let logger = Logger::new(LogLevel::from(log_level as u8));

    match opt.clone().cmd {
        Subcommands::Build(build_opt) => match builder::build(&logger, &opt, &build_opt) {
            Ok(_) => {
                logger.log(LogLevel::DETAILER, "Building finished successfully.");
                Ok(())
            }
            Err(err) => {
                logger.log(err.severity(), err.description());
                logger.log(LogLevel::SEVERE, "Aborting building due to error.");
                Err(())
            }
        },
        Subcommands::New(new_opt) => match new_page::generate_new_page(&logger, &opt, &new_opt) {
            Ok(_) => {
                logger.log(
                    LogLevel::DETAILER,
                    "Generating the new page finished successfully.",
                );
                Ok(())
            }
            Err(err) => {
                logger.log(err.severity(), err.description());
                logger.log(LogLevel::SEVERE, "Aborting building due to error.");
                Err(())
            }
        },
        Subcommands::Initialize(init_opt) => {
            logger.log(LogLevel::DETAIL, "Generating config.toml");

            let mut navbar = None;
            if !init_opt.no_default_navbar {
                let mut hashmap = HashMap::new();
                hashmap.insert(
                    "test".to_owned(),
                    NavbarItem {
                        title: "Home".to_owned(),
                        link: "/home.html".to_owned(),
                        image_url: Some("/img/image.png".to_owned()),
                    },
                );
                hashmap.insert(
                    "other".to_owned(),
                    NavbarItem {
                        title: "Other".to_owned(),
                        link: "/other.html".to_owned(),
                        image_url: None,
                    },
                );
                navbar = Some(NavbarConfig {
                    items: vec!["test".to_owned(), "other".to_owned()],
                    item_map: hashmap,
                })
            }

            let config = GlobalConfigToml {
                website: WebsiteConfig {
                    website_name: init_opt.name,
                    built_pages: Vec::new(),
                    use_default_css: true,
                    use_default_js: true,
                    javascript: Vec::new(),
                    css: Vec::new(),
                    favicon: init_opt.favicon,
                    before_navbar_url: None,
                    before_content_url: None,
                    after_content_url: None,

                    mobile_viewport: None,
                    meta_description: None,
                    charset: Some("utf-8".to_owned()),
                    meta_og: None,

                    output: None,
                },
                navbar: navbar,
                resources: None,
                twitter: None,
                google: None,
            };

            match file_writer::write_toml(&PathBuf::from("config.toml"), &config, opt.overwrite) {
                Ok(_) => {
                    logger.log(LogLevel::INFO, "Done!");
                    Ok(())
                }
                Err(err) => {
                    logger.log(
                        err.severity(),
                        format!("Initialization failed: {}", err.description()),
                    );
                    Err(())
                }
            }
        }
    }
}