extern crate dirs;
extern crate notify_rust;
extern crate hyper;

use std::io;
use std::process::{Command, ExitStatus};
use std::path::PathBuf;
use std::fs::{File, create_dir_all};

use notify_rust::Notification;

/// The different types of error that can occur.
#[derive(Debug)]
pub enum Error {
    /// No builder can build this project.
    NoBuilderFound,

    /// An io::Error happened while running a build command.
    IoError(io::Error),

    /// A command exited with non-zero exit code.
    CommandError(String, Vec<String>, ExitStatus),
}

impl From<io::Error> for Error {
    fn from(e: io::Error) -> Error {
        Error::IoError(e)
    }
}

/// Tests if a file is in a directory.
pub fn contains_file(path: &str, file: &str) -> bool {
    let mut path = PathBuf::from(path);
    path.push(file);
    path.exists()
}

/// Tries to build a certain directory using the specified builders.
pub fn run_command(command: &str, path: &str) -> Result<(), Error> {
    run_command_with_args(command, path, vec![])
}

/// Run a build commands, and wait untils its finished, returning its result.
pub fn run_command_with_args(command: &str, path: &str, args: Vec<&str>) -> Result<(), Error> {

    let new_args: Vec<String> = args.iter().map(|x| String::from(*x)).collect();

    let mut child = Command::new(command)
        .current_dir(path)
        .args(args)
        .spawn()?;

    let exit = child.wait()?;

    if exit.success() {
        Ok(())
    } else {
        Err(Error::CommandError(command.to_owned(), new_args, exit))
    }
}

/// Tries to build a certain directory using the specified builders.
pub fn build(path: &PathBuf, builders: &Vec<Box<Builder>>) -> Result<(), Error> {

    let mut path = path.clone();

    loop {

        if path.to_str().unwrap() == "/" {
            // Couldn't find a buildable directory
            return Err(Error::NoBuilderFound);
        }

        for builder in builders {

            if builder.is_buildable(path.to_str().unwrap()) {
                builder.build(path.to_str().unwrap())?;
                return Ok(());
            }

        }

        path.pop();
    };

}

/// Destucture a Result to return a Result<(), ()>
pub fn destroy<T, E>(result: Result<T, E>) -> Result<(), ()> {
    match result {
        Err(_) => Err(()),
        Ok(_) => Ok(()),
    }
}

/// A general builders that contains many builders and can build any type of code.
pub struct GeneralBuilder {
    /// The path to the success icon.
    success: PathBuf,

    /// The path to the failure icon.
    failure: PathBuf,

    /// The builders contained.
    builders: Vec<Box<Builder>>,
}

impl GeneralBuilder {
    /// Creates a new general builder with the defaults builders.
    pub fn new() -> GeneralBuilder {

        let mut config = PathBuf::from(dirs::config_dir().unwrap());
        config.push("mars");

        let mut success = config.clone();
        success.push("success.png");

        let mut failure = config.clone();
        failure.push("failure.png");

        if ! success.exists() || ! failure.exists() {

            create_dir_all(&config).unwrap();

            const SUCCESS_BYTES: &[u8] = include_bytes!("../assets/success.png");
            const FAILURE_BYTES: &[u8] = include_bytes!("../assets/failure.png");

            use std::io::Write;

            let mut path = config.clone();
            path.push("success.png");

            let mut success_file = File::create(&success).unwrap();
            success_file.write_all(SUCCESS_BYTES).unwrap();

            let mut path = config.clone();
            path.push("success.png");

            let mut failure_file = File::create(&failure).unwrap();
            failure_file.write_all(FAILURE_BYTES).unwrap();
        }

        GeneralBuilder {
            success: success,
            failure: failure,
            builders: vec![
                Box::new(MakeBuilder::new()),
                Box::new(CMakeBuilder::new()),
                Box::new(CargoBuilder::new()),
            ],
        }
    }

    /// Triggers a build.
    pub fn build(&self, path: &str) -> Result<(), Error> {
        let result = build(&PathBuf::from(path), &self.builders);

        match result {
            Ok(_) => self.notify_success(),
            Err(ref e) => self.notify_error(&e),
       }

        result
    }

    /// Sends a notification of a successful build.
    pub fn notify_success(&self) {

        let _ = Notification::new()
            .appname("Mars")
            .summary("Success")
            .body("Mars finished successfully")
            .icon(self.success.to_str().unwrap())
            .show();

    }

    /// Sends a notification of an error.
    pub fn notify_error(&self, e: &Error) {

        let body = match e {
            Error::NoBuilderFound => "No builder was found for this directory".to_string(),
            Error::IoError(ref e) => format!("Error while running command: {:?}", e).to_string(),
            Error::CommandError(ref command, ref args, ref status) => {
                let status = match status.code() {
                    None => "None".to_owned(),
                    Some(e) => e.to_string(),
                };

                format!("Command \"{} {}\" failed: {}",
                    command, args.join(" "), status).to_string()
            },
        };

        let _ = Notification::new()
            .appname("Mars")
            .summary("Failure")
            .body(&body)
            .icon(self.failure.to_str().unwrap())
            .show();

    }

}

/// A generic builder. It can build some projects.
pub trait Builder {
    /// Checks if a directory has corresponding files so it can build it.
    /// e.g.: if there is a Makefile
    fn is_buildable(&self, path: &str) -> bool;

    /// Trigger all the commands to build the project.
    fn build(&self, path: &str) -> Result<(), Error>;
}

/// The builder that looks for makefiles.
pub struct MakeBuilder;

impl MakeBuilder {
    /// Creates a new make builder.
    pub fn new() -> MakeBuilder {
        MakeBuilder
    }
}

impl Builder for MakeBuilder {
    fn is_buildable(&self, path: &str) -> bool {
        contains_file(path, "Makefile")
    }

    fn build(&self, path: &str) -> Result<(), Error> {
        run_command("make", path)?;
        Ok(())
    }
}

/// The builder that builds cmake projects.
pub struct CMakeBuilder;

impl CMakeBuilder {
    /// Creates a new cmake builder.
    pub fn new() -> CMakeBuilder {
        CMakeBuilder
    }
}

impl Builder for CMakeBuilder {
    fn is_buildable(&self, path: &str) -> bool {
        contains_file(path, "CMakeLists.txt")
    }

    fn build(&self, path: &str) -> Result<(), Error> {

        let mut build = PathBuf::from(path);
        build.push("build");

        // If there's a build/Makefile, we'll only make
        if ! contains_file(path, "build/Makefile") {

            // Create build directory
            create_dir_all(&build)?;

            // Run cmake .. in build directory
            run_command_with_args("cmake", build.to_str().unwrap(), vec![".."])?;
        }

        // Run make in build directory
        run_command("make", build.to_str().unwrap())?;
        Ok(())
    }

}

/// The builder that looks for Cargo.toml.
pub struct CargoBuilder;

impl CargoBuilder {
    /// Creates a new cargo builder.
    pub fn new() -> CargoBuilder {
        CargoBuilder
    }
}

impl Builder for CargoBuilder {
    fn is_buildable(&self, path: &str) -> bool {
        contains_file(path, "Cargo.toml")
    }

    fn build(&self, path: &str) -> Result<(), Error> {
        run_command_with_args("cargo", path, vec!["build"])
    }
}