extern crate log;

use clap::App;

use clap::AppSettings;

use clap::ArgMatches;

use format_bytes::format_bytes;

mod commands;

mod error;

mod exitcode;

mod ui;

use error::CommandError;

fn main() {

    env_logger::init();

    let app = App::new("rhg")

        .setting(AppSettings::AllowInvalidUtf8)

        .setting(AppSettings::SubcommandRequired)

        .setting(AppSettings::VersionlessSubcommands)

        .version("0.0.1")

    let matches = app.clone().get_matches_safe().unwrap_or_else(|err| {

        let _ = ui::Ui::new().writeln_stderr_str(&err.message);

        std::process::exit(exitcode::UNIMPLEMENTED)

    });

    let ui = ui::Ui::new();

    let command_result = match_subcommand(matches, &ui);

    let exit_code = match command_result {

        Ok(_) => exitcode::OK,

        // Exit with a specific code and no error message to let a potential

        // wrapper script fallback to Python-based Mercurial.

        Err(CommandError::Unimplemented) => exitcode::UNIMPLEMENTED,

        Err(CommandError::Abort { message }) => {

            if !message.is_empty() {

                // Ignore errors when writing to stderr, we’re already exiting

                // with failure code so there’s not much more we can do.

                let _ =

                    ui.write_stderr(&format_bytes!(b"abort: {}\n", message));

            }

            exitcode::ABORT

        }

    };

    std::process::exit(exit_code)

}

fn match_subcommand(

    matches: ArgMatches,

    ui: &ui::Ui,

) -> Result<(), CommandError> {

    let config = hg::config::Config::load()?;

    match matches.subcommand() {

        ("root", Some(matches)) => commands::root::run(ui, &config, matches),

        ("files", Some(matches)) => commands::files::run(ui, &config, matches),

        ("cat", Some(matches)) => commands::cat::run(ui, &config, matches),

        ("debugdata", Some(matches)) => {

            commands::debugdata::run(ui, &config, matches)

        }

        ("debugrequirements", Some(matches)) => {

            commands::debugrequirements::run(ui, &config, matches)

        }

        _ => unreachable!(), // Because of AppSettings::SubcommandRequired,

    }

}