extern crate log;

use crate::error::CommandError;

use crate::ui::{local_to_utf8, 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::SliceExt;

use hg::{exit_codes, requirements};

use std::borrow::Cow;

use std::collections::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 app = add_subcommand_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 = subcommand_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")