extern crate log;

use crate::error::CommandError;

use crate::ui::Ui;

use clap::{command, Arg, ArgMatches};

use format_bytes::{format_bytes, join};

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

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

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

use hg::utils::strings::SliceExt;

use hg::{exit_codes, requirements};

use std::borrow::Cow;

use std::collections::{HashMap, HashSet};

use std::ffi::OsString;

use std::os::unix::prelude::CommandExt;

use std::path::PathBuf;

use std::process::Command;

mod blackbox;

mod color;

mod error;

mod ui;

pub mod utils {

    pub mod path_utils;

}

fn main_with_result(

    argv: Vec<OsString>,

    process_start_time: &blackbox::ProcessStartTime,

    ui: &ui::Ui,

    repo: Result<&Repo, &NoRepoInCwdError>,

    config: &Config,

) -> Result<(), CommandError> {

    check_unsupported(config, repo)?;

    let app = command!()

        .subcommand_required(true)

        .arg(

            Arg::new("repository")

                .help("repository root directory")

                .short('R')

                .value_name("REPO")

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

                .global(true),

        )

        .arg(

            Arg::new("config")

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

                .value_name("CONFIG")

                .global(true)

                .long("config")

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

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

                .action(clap::ArgAction::Append),

        )

        .arg(

            Arg::new("cwd")

                .help("change working directory")

                .value_name("DIR")

                .long("cwd")

                .global(true),

        )

        .arg(

            Arg::new("color")

                .help("when to colorize (boolean, always, auto, never, or debug)")

                .value_name("TYPE")

                .long("color")

                .global(true),

        )

        .version("0.0.1");

    let subcommands = subcommands();

    let app = subcommands.add_args(app);

    let matches = app.try_get_matches_from(argv.iter())?;

    let (subcommand_name, subcommand_args) =

        matches.subcommand().expect("subcommand required");

    // Mercurial allows users to define "defaults" for commands, fallback

    // if a default is detected for the current command

    let defaults = config.get_str(b"defaults", subcommand_name.as_bytes())?;

    match defaults {

        // Programmatic usage might set defaults to an empty string to unset

        // it; allow that

        None | Some("") => {}

        Some(_) => {

            let msg = "`defaults` config set";

            return Err(CommandError::unsupported(msg));

        }

    }

    for prefix in ["pre", "post", "fail"].iter() {

        // Mercurial allows users to define generic hooks for commands,

        // fallback if any are detected

        let item = format!("{}-{}", prefix, subcommand_name);

        let hook_for_command =

            config.get_str_no_default(b"hooks", item.as_bytes())?;

        if hook_for_command.is_some() {

            let msg = format!("{}-{} hook defined", prefix, subcommand_name);

            return Err(CommandError::unsupported(msg));

        }

    }

    let run = subcommands.run_fn(subcommand_name)

        .expect("unknown subcommand name from clap despite Command::subcommand_required");

    let invocation = CliInvocation {

        ui,

        subcommand_args,

        config,

        repo,

    };

    if let Ok(repo) = repo {

        // We don't support subrepos, fallback if the subrepos file is present

        if repo.working_directory_vfs().join(".hgsub").exists() {

            let msg = "subrepos (.hgsub is present)";

            return Err(CommandError::unsupported(msg));

        }

    }

    if config.is_extension_enabled(b"blackbox") {

        let blackbox =

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

        blackbox.log_command_start(argv.iter());

        let result = run(&invocation);

        blackbox.log_command_end(

            argv.iter(),

            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

    } else {

        run(&invocation)

    }

}

fn rhg_main(argv: Vec<OsString>) -> ! {

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

    // Make sure nothing in a future version of `rhg` sets the global

    // threadpool before we can cap default threads. (This is also called

    // in core because Python uses the same code path, we're adding a

    // redundant check.)

    hg::utils::cap_default_rayon_threads()

        .expect("Rayon threadpool already initialized");

    let early_args = EarlyArgs::parse(&argv);

    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(

                    &argv,

                    &None,

                    &Ui::new_infallible(&Config::empty()),

                    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(

                &argv,

                &initial_current_dir,

                &Ui::new_infallible(&Config::empty()),

                on_unsupported,

                Err(error.into()),

                false,

            )

        });

    non_repo_config

        .load_cli_args(early_args.config, early_args.color)

        .unwrap_or_else(|error| {

            exit(

                &argv,

                &initial_current_dir,

                &Ui::new_infallible(&non_repo_config),

                OnUnsupported::from_config(&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(

                &argv,

                &initial_current_dir,

                &Ui::new_infallible(&non_repo_config),

                OnUnsupported::from_config(&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_default();

    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.is_empty() => 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.is_empty() => {

                            // 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_else(|| Some(get_path_from_bytes(&repo_arg).to_path_buf()))

        }

    };

    let simple_exit =

        |ui: &Ui, config: &Config, result: Result<(), CommandError>| -> ! {

            exit(

                &argv,

                &initial_current_dir,

                ui,

                OnUnsupported::from_config(config),

                result,

                // 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 early_exit = |config: &Config, error: CommandError| -> ! {

        simple_exit(&Ui::new_infallible(config), config, Err(error))

    };

    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) => early_exit(&non_repo_config, error.into()),

    };

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

        repo.config()

    } else {

        &non_repo_config

    };

    let mut config_cow = Cow::Borrowed(config);

    config_cow.to_mut().apply_plain(PlainInfo::from_env());

    if !ui::plain(Some("tweakdefaults"))

        && config_cow

            .as_ref()

            .get_bool(b"ui", b"tweakdefaults")

            .unwrap_or_else(|error| early_exit(config, error.into()))

    {

        config_cow.to_mut().tweakdefaults()

    };

    let config = config_cow.as_ref();

    let ui = Ui::new(config)

        .unwrap_or_else(|error| early_exit(config, error.into()));

    if let Ok(true) = config.get_bool(b"rhg", b"fallback-immediately") {

        exit(

            &argv,

            &initial_current_dir,

            &ui,

            OnUnsupported::fallback(config),

            Err(CommandError::unsupported(

                "`rhg.fallback-immediately is true`",

            )),

            false,

        )

    }

    let result = main_with_result(

        argv.iter().map(|s| s.to_owned()).collect(),

        &process_start_time,

        &ui,

        repo_result.as_ref(),

        config,

    );

    simple_exit(&ui, config, result)

}

fn main() -> ! {

    rhg_main(std::env::args_os().collect())

}

fn exit_code(

    result: &Result<(), CommandError>,

    use_detailed_exit_code: bool,

) -> i32 {

    match result {

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

        Err(CommandError::Abort {

            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

        }

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

            exit_codes::INVALID_FALLBACK

        }

    }

}

fn exit(

    original_args: &[OsString],

    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 { message }),

    ) = (&on_unsupported, &result)

    {

        let mut args = original_args.iter();

        let executable = match executable {

            None => {

                exit_no_fallback(

                    ui,

                    OnUnsupported::Abort,

                    Err(CommandError::abort(

                        "abort: 'rhg.on-unsupported=fallback' without \

                                'rhg.fallback-executable' set.",

                    )),

                    false,

                );

            }

            Some(executable) => executable,

        };

        let executable_path = get_path_from_bytes(executable);

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

        if executable_path == *this_executable {

            // Avoid spawning infinitely many processes until resource

            // exhaustion.

            let _ = ui.write_stderr(&format_bytes!(

                b"Blocking recursive fallback. The 'rhg.fallback-executable = {}' config \

                points to `rhg` itself.\n",

                executable

            ));

            on_unsupported = OnUnsupported::Abort

        } else {

            log::debug!("falling back (see trace-level log)");

            log::trace!("{}", String::from_utf8_lossy(message));

            if let Err(err) = which::which(executable_path) {

                exit_no_fallback(

                    ui,

                    OnUnsupported::Abort,

                    Err(CommandError::InvalidFallback {

                        path: executable.to_owned(),

                        err: err.to_string(),

                    }),

                    use_detailed_exit_code,

                )

            }

            // `args` is now `argv[1..]` since we’ve already consumed

            // `argv[0]`

            let mut command = Command::new(executable_path);

            command.args(args);

            if let Some(initial) = initial_current_dir {

                command.current_dir(initial);

            }

            // We don't use subprocess because proper signal handling is harder

            // and we don't want to keep `rhg` around after a fallback anyway.

            // For example, if `rhg` is run in the background and falls back to

            // `hg` which, in turn, waits for a signal, we'll get stuck if

            // we're doing plain subprocess.

            //

            // If `exec` returns, we can only assume our process is very broken

            // (see its documentation), so only try to forward the error code

            // when exiting.

            let err = command.exec();

            std::process::exit(

                err.raw_os_error().unwrap_or(exit_codes::ABORT),

            );

        }

    }

    exit_no_fallback(ui, on_unsupported, result, use_detailed_exit_code)