extern crate log;

use crate::ui::Ui;

use clap::App;

use clap::AppSettings;

use clap::Arg;

use clap::ArgMatches;

use format_bytes::{format_bytes, join};

use hg::config::{Config, ConfigSource};

use hg::exit_codes;

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

use hg::utils::files::{get_bytes_from_os_str, get_path_from_bytes};

use hg::utils::SliceExt;

use std::ffi::OsString;

use std::path::PathBuf;

use std::process::Command;

mod blackbox;

mod error;

mod ui;

use error::CommandError;

fn main_with_result(

    process_start_time: &blackbox::ProcessStartTime,

    ui: &ui::Ui,

    repo: Result<&Repo, &NoRepoInCwdError>,

    config: &Config,

) -> Result<(), CommandError> {

    check_extensions(config)?;

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

        .global_setting(AppSettings::AllowInvalidUtf8)

        .global_setting(AppSettings::DisableVersion)

        .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),

        )

        .arg(

            Arg::with_name("cwd")

                .help("change working directory")

                .long("--cwd")

                .value_name("DIR")

                .takes_value(true)

                .global(true),

        )

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

        config,

        repo,

    };

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

    blackbox.log_command_start();

    let result = run(&invocation);

    blackbox.log_command_end(exit_code(

        &result,

        // TODO: show a warning or combine with original error if `get_bool`

        // returns an error

        config

            .get_bool(b"ui", b"detailed-exit-code")

            .unwrap_or(false),

    ));

    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();

    env_logger::init();

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

    let early_args = EarlyArgs::parse(std::env::args_os());

    let initial_current_dir = early_args.cwd.map(|cwd| {

        let cwd = get_path_from_bytes(&cwd);

        std::env::current_dir()

            .and_then(|initial| {

                std::env::set_current_dir(cwd)?;

                Ok(initial)

            })

            .unwrap_or_else(|error| {

                exit(

                    &None,

                    &ui,

                    OnUnsupported::Abort,

                    Err(CommandError::abort(format!(

                        "abort: {}: '{}'",

                        error,

                        cwd.display()

                    ))),

                    false,

                )

            })

    });

    let mut non_repo_config =

        Config::load_non_repo().unwrap_or_else(|error| {

            // Normally this is decided based on config, but we don’t have that

            // available. As of this writing config loading never returns an

            // "unsupported" error but that is not enforced by the type system.

            let on_unsupported = OnUnsupported::Abort;

            exit(

                &initial_current_dir,

                &ui,

                on_unsupported,

                Err(error.into()),

                false,

            )

        });

    non_repo_config

        .load_cli_args_config(early_args.config)

        .unwrap_or_else(|error| {

            exit(

                &initial_current_dir,

                &ui,

                OnUnsupported::from_config(&ui, &non_repo_config),

                Err(error.into()),

                non_repo_config

                    .get_bool(b"ui", b"detailed-exit-code")

                    .unwrap_or(false),

            )

        });

    if let Some(repo_path_bytes) = &early_args.repo {

        lazy_static::lazy_static! {

            static ref SCHEME_RE: regex::bytes::Regex =

                // Same as `_matchscheme` in `mercurial/util.py`

                regex::bytes::Regex::new("^[a-zA-Z0-9+.\\-]+:").unwrap();

        }

        if SCHEME_RE.is_match(&repo_path_bytes) {

            exit(

                &initial_current_dir,

                &ui,

                OnUnsupported::from_config(&ui, &non_repo_config),

                Err(CommandError::UnsupportedFeature {

                    message: format_bytes!(

                        b"URL-like --repository {}",

                        repo_path_bytes

                    ),

                }),

                // TODO: show a warning or combine with original error if

                // `get_bool` returns an error

                non_repo_config

                    .get_bool(b"ui", b"detailed-exit-code")

                    .unwrap_or(false),

            )

        }

    }

    let repo_arg = early_args.repo.unwrap_or(Vec::new());

    let repo_path: Option<PathBuf> = {

        if repo_arg.is_empty() {

            None

        } else {

            let local_config = {

                if std::env::var_os("HGRCSKIPREPO").is_none() {

                    // TODO: handle errors from find_repo_root

                    if let Ok(current_dir_path) = Repo::find_repo_root() {

                        let config_files = vec![

                            ConfigSource::AbsPath(

                                current_dir_path.join(".hg/hgrc"),

                            ),

                            ConfigSource::AbsPath(

                                current_dir_path.join(".hg/hgrc-not-shared"),

                            ),

                        ];

                        // TODO: handle errors from

                        // `load_from_explicit_sources`

                        Config::load_from_explicit_sources(config_files).ok()

                    } else {

                        None

                    }

                } else {

                    None

                }

            };

            let non_repo_config_val = {

                let non_repo_val = non_repo_config.get(b"paths", &repo_arg);

                match &non_repo_val {

                    Some(val) if val.len() > 0 => home::home_dir()

                        .unwrap_or_else(|| PathBuf::from("~"))

                        .join(get_path_from_bytes(val))

                        .canonicalize()

                        // TODO: handle error and make it similar to python

                        // implementation maybe?

                        .ok(),

                    _ => None,

                }

            };

            let config_val = match &local_config {

                None => non_repo_config_val,

                Some(val) => {

                    let local_config_val = val.get(b"paths", &repo_arg);

                    match &local_config_val {

                        Some(val) if val.len() > 0 => {

                            // presence of a local_config assures that

                            // current_dir

                            // wont result in an Error

                            let canpath = hg::utils::current_dir()

                                .unwrap()

                                .join(get_path_from_bytes(val))

                                .canonicalize();

                            canpath.ok().or(non_repo_config_val)

                        }

                        _ => non_repo_config_val,

                    }

                }

            };

            config_val.or(Some(get_path_from_bytes(&repo_arg).to_path_buf()))

        }

    };

    let repo_result = match Repo::find(&non_repo_config, repo_path.to_owned())

    {

        Ok(repo) => Ok(repo),

        Err(RepoError::NotFound { at }) if repo_path.is_none() => {

            // Not finding a repo is not fatal yet, if `-R` was not given

            Err(NoRepoInCwdError { cwd: at })

        }

        Err(error) => exit(

            &initial_current_dir,

            &ui,

            OnUnsupported::from_config(&ui, &non_repo_config),

            Err(error.into()),

            // TODO: show a warning or combine with original error if

            // `get_bool` returns an error

            non_repo_config

                .get_bool(b"ui", b"detailed-exit-code")

                .unwrap_or(false),

        ),

    };

    let config = if let Ok(repo) = &repo_result {

        repo.config()

    } else {

        &non_repo_config

    };

    let on_unsupported = OnUnsupported::from_config(&ui, config);

    let result = main_with_result(

        &process_start_time,

        &ui,

        repo_result.as_ref(),

        config,

    );

    exit(

        &initial_current_dir,

        &ui,

        on_unsupported,

        result,

        // TODO: show a warning or combine with original error if `get_bool`

        // returns an error

        config

            .get_bool(b"ui", b"detailed-exit-code")

            .unwrap_or(false),

    )

}

fn exit_code(

    result: &Result<(), CommandError>,

    use_detailed_exit_code: bool,

) -> i32 {

    match result {

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

        Err(CommandError::Abort {

            message: _,

            detailed_exit_code,

        }) => {

            if use_detailed_exit_code {

                *detailed_exit_code

            } else {

                exit_codes::ABORT

            }

        }

        Err(CommandError::Unsuccessful) => exit_codes::UNSUCCESSFUL,

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

        // wrapper script fallback to Python-based Mercurial.

        Err(CommandError::UnsupportedFeature { .. }) => {

            exit_codes::UNIMPLEMENTED

        }

    }

}

fn exit(

    initial_current_dir: &Option<PathBuf>,

    ui: &Ui,

    mut on_unsupported: OnUnsupported,

    result: Result<(), CommandError>,

    use_detailed_exit_code: bool,

) -> ! {

    if let (

        OnUnsupported::Fallback { executable },

        Err(CommandError::UnsupportedFeature { .. }),

    ) = (&on_unsupported, &result)

    {

        let mut args = std::env::args_os();

        let executable_path = get_path_from_bytes(&executable);

        let this_executable = args.next().expect("exepcted argv[0] to exist");

        if executable_path == &PathBuf::from(this_executable) {