extern crate log;

use crate::ui::Ui;

use clap::App;

use clap::AppSettings;

use clap::Arg;

use clap::ArgMatches;

use format_bytes::format_bytes;

use hg::config::Config;

use hg::repo::{Repo, RepoError};

mod blackbox;

mod error;

mod exitcode;

mod ui;

use error::CommandError;

fn main_with_result(

    ui: &ui::Ui,

) -> Result<(), CommandError> {

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

        .global_setting(AppSettings::AllowInvalidUtf8)

        .setting(AppSettings::SubcommandRequired)

        .setting(AppSettings::VersionlessSubcommands)

        .arg(

            Arg::with_name("repository")

                .help("repository root directory")

                .short("-R")

                .long("--repository")

                .value_name("REPO")

                .takes_value(true)

                // Both ok: `hg -R ./foo log` or `hg log -R ./foo`

                .global(true),

        )

        .arg(

            Arg::with_name("config")

                .help("set/override config option (use 'section.name=value')")

                .long("--config")

                .value_name("CONFIG")

                .takes_value(true)

                .global(true)

                // Ok: `--config section.key1=val --config section.key2=val2`

                .multiple(true)

                // Not ok: `--config section.key1=val section.key2=val2`

                .number_of_values(1),

        )

        .version("0.0.1");

    let app = add_subcommand_args(app);

    let matches = app.clone().get_matches_safe()?;

    let (subcommand_name, subcommand_matches) = matches.subcommand();

    let run = subcommand_run_fn(subcommand_name)

        .expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired");

    let subcommand_args = subcommand_matches

        .expect("no subcommand arguments from clap despite AppSettings::SubcommandRequired");

    let invocation = CliInvocation {

        ui,

        subcommand_args,

    };

    let blackbox = blackbox::Blackbox::new(&invocation, process_start_time)?;

    blackbox.log_command_start();

    let result = run(&invocation);

    blackbox.log_command_end(exit_code(&result));

    result

}

fn main() {

    // Run this first, before we find out if the blackbox extension is even

    // enabled, in order to include everything in-between in the duration

    // measurements. Reading config files can be slow if they’re on NFS.

    let process_start_time = blackbox::ProcessStartTime::now();

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

        }

}

fn exit_code(result: &Result<(), CommandError>) -> i32 {

    match result {

        Ok(()) => exitcode::OK,

        Err(CommandError::Abort { .. }) => exitcode::ABORT,

        // 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,

    }

}

macro_rules! subcommands {

    ($( $command: ident )+) => {

        mod commands {

            $(

                pub mod $command;

            )+

        }

        fn add_subcommand_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {

            app

            $(

                .subcommand(commands::$command::args())

            )+

        }

        pub type RunFn = fn(&CliInvocation) -> Result<(), CommandError>;

        fn subcommand_run_fn(name: &str) -> Option<RunFn> {

            match name {

                $(

                    stringify!($command) => Some(commands::$command::run),

                )+

                _ => None,

            }

        }

    };

}

subcommands! {

    cat

    debugdata

    debugrequirements

    files

    root

    config

}

pub struct CliInvocation<'a> {

    ui: &'a Ui,

    subcommand_args: &'a ArgMatches<'a>,

    /// References inside `Result` is a bit peculiar but allow

    /// `invocation.repo?` to work out with `&CliInvocation` since this

    /// `Result` type is `Copy`.

    repo: Result<&'a Repo, &'a NoRepoInCwdError>,

}

struct NoRepoInCwdError {

    cwd: PathBuf,

}

        }

    }

}