//! Error reporting
#![allow(deprecated)]

// Std
use std::{
    borrow::Cow,
    convert::From,
    error,
    fmt::{self, Debug, Display, Formatter},
    io::{self, BufRead},
    result::Result as StdResult,
};

// Internal
use crate::output::fmt::Colorizer;
use crate::output::fmt::Stream;
use crate::parser::features::suggestions;
use crate::util::{color::ColorChoice, safe_exit, SUCCESS_CODE, USAGE_CODE};
use crate::AppSettings;
use crate::Command;

mod context;
mod kind;

pub use context::ContextKind;
pub use context::ContextValue;
pub use kind::ErrorKind;

/// Short hand for [`Result`] type
///
/// [`Result`]: std::result::Result
pub type Result<T, E = Error> = StdResult<T, E>;

/// Command Line Argument Parser Error
///
/// See [`Command::error`] to create an error.
///
/// [`Command::error`]: crate::Command::error
#[derive(Debug)]
pub struct Error {
    inner: Box<ErrorInner>,
    /// Deprecated, replaced with [`Error::kind()`]
    #[cfg_attr(
        feature = "deprecated",
        deprecated(since = "3.1.0", note = "Replaced with `Error::kind()`")
    )]
    pub kind: ErrorKind,
    /// Deprecated, replaced with [`Error::context()`]
    #[cfg_attr(
        feature = "deprecated",
        deprecated(since = "3.1.0", note = "Replaced with `Error::context()`")
    )]
    pub info: Vec<String>,
}

#[derive(Debug)]
struct ErrorInner {
    kind: ErrorKind,
    context: Vec<(ContextKind, ContextValue)>,
    message: Option<Message>,
    source: Option<Box<dyn error::Error + Send + Sync>>,
    help_flag: Option<&'static str>,
    color_when: ColorChoice,
    wait_on_exit: bool,
    backtrace: Option<Backtrace>,
}

impl Error {
    /// Create an unformatted error
    ///
    /// This is for you need to pass the error up to
    /// a place that has access to the `Command` at which point you can call [`Error::format`].
    ///
    /// Prefer [`Command::error`] for generating errors.
    ///
    /// [`Command::error`]: crate::Command::error
    pub fn raw(kind: ErrorKind, message: impl std::fmt::Display) -> Self {
        Self::new(kind).set_message(message.to_string())
    }

    /// Format the existing message with the Command's context
    #[must_use]
    pub fn format(mut self, cmd: &mut Command) -> Self {
        cmd._build_self();
        let usage = cmd.render_usage();
        if let Some(message) = self.inner.message.as_mut() {
            message.format(cmd, usage);
        }
        self.with_cmd(cmd)
    }

    /// Type of error for programmatic processing
    pub fn kind(&self) -> ErrorKind {
        self.inner.kind
    }

    /// Additional information to further qualify the error
    pub fn context(&self) -> impl Iterator<Item = (ContextKind, &ContextValue)> {
        self.inner.context.iter().map(|(k, v)| (*k, v))
    }

    /// Should the message be written to `stdout` or not?
    #[inline]
    pub fn use_stderr(&self) -> bool {
        self.stream() == Stream::Stderr
    }

    pub(crate) fn stream(&self) -> Stream {
        match self.kind() {
            ErrorKind::DisplayHelp | ErrorKind::DisplayVersion => Stream::Stdout,
            _ => Stream::Stderr,
        }
    }

    /// Prints the error and exits.
    ///
    /// Depending on the error kind, this either prints to `stderr` and exits with a status of `2`
    /// or prints to `stdout` and exits with a status of `0`.
    pub fn exit(&self) -> ! {
        if self.use_stderr() {
            // Swallow broken pipe errors
            let _ = self.print();

            if self.inner.wait_on_exit {
                wlnerr!("\nPress [ENTER] / [RETURN] to continue...");
                let mut s = String::new();
                let i = io::stdin();
                i.lock().read_line(&mut s).unwrap();
            }

            safe_exit(USAGE_CODE);
        }

        // Swallow broken pipe errors
        let _ = self.print();
        safe_exit(SUCCESS_CODE)
    }

    /// Prints formatted and colored error to `stdout` or `stderr` according to its error kind
    ///
    /// # Example
    /// ```no_run
    /// use clap::Command;
    ///
    /// match Command::new("Command").try_get_matches() {
    ///     Ok(matches) => {
    ///         // do_something
    ///     },
    ///     Err(err) => {
    ///         err.print().expect("Error writing Error");
    ///         // do_something
    ///     },
    /// };
    /// ```
    pub fn print(&self) -> io::Result<()> {
        self.formatted().print()
    }

    /// Deprecated, replaced with [`Command::error`]
    ///
    /// [`Command::error`]: crate::Command::error
    #[cfg_attr(
        feature = "deprecated",
        deprecated(since = "3.0.0", note = "Replaced with `Command::error`")
    )]
    #[doc(hidden)]
    pub fn with_description(description: String, kind: ErrorKind) -> Self {
        Error::raw(kind, description)
    }

    fn new(kind: ErrorKind) -> Self {
        Self {
            inner: Box::new(ErrorInner {
                kind,
                context: Vec::new(),
                message: None,
                source: None,
                help_flag: None,
                color_when: ColorChoice::Never,
                wait_on_exit: false,
                backtrace: Backtrace::new(),
            }),
            kind,
            info: vec![],
        }
    }

    #[inline(never)]
    fn for_app(kind: ErrorKind, cmd: &Command, colorizer: Colorizer, info: Vec<String>) -> Self {
        Self::new(kind)
            .set_message(colorizer)
            .with_cmd(cmd)
            .set_info(info)
    }

    pub(crate) fn with_cmd(self, cmd: &Command) -> Self {
        self.set_wait_on_exit(cmd.is_set(AppSettings::WaitOnError))
            .set_color(cmd.get_color())
            .set_help_flag(get_help_flag(cmd))
    }

    pub(crate) fn set_message(mut self, message: impl Into<Message>) -> Self {
        self.inner.message = Some(message.into());
        self
    }

    pub(crate) fn set_info(mut self, info: Vec<String>) -> Self {
        self.info = info;
        self
    }

    pub(crate) fn set_source(mut self, source: Box<dyn error::Error + Send + Sync>) -> Self {
        self.inner.source = Some(source);
        self
    }

    pub(crate) fn set_color(mut self, color_when: ColorChoice) -> Self {
        self.inner.color_when = color_when;
        self
    }

    pub(crate) fn set_help_flag(mut self, help_flag: Option<&'static str>) -> Self {
        self.inner.help_flag = help_flag;
        self
    }

    pub(crate) fn set_wait_on_exit(mut self, yes: bool) -> Self {
        self.inner.wait_on_exit = yes;
        self
    }

    /// Does not verify if `ContextKind` is already present
    #[inline(never)]
    pub(crate) fn insert_context_unchecked(
        mut self,
        kind: ContextKind,
        value: ContextValue,
    ) -> Self {
        self.inner.context.push((kind, value));
        self
    }

    /// Does not verify if `ContextKind` is already present
    #[inline(never)]
    pub(crate) fn extend_context_unchecked<const N: usize>(
        mut self,
        context: [(ContextKind, ContextValue); N],
    ) -> Self {
        self.inner.context.extend(context);
        self
    }

    #[inline(never)]
    fn get_context(&self, kind: ContextKind) -> Option<&ContextValue> {
        self.inner
            .context
            .iter()
            .find_map(|(k, v)| (*k == kind).then(|| v))
    }

    pub(crate) fn display_help(cmd: &Command, colorizer: Colorizer) -> Self {
        Self::for_app(ErrorKind::DisplayHelp, cmd, colorizer, vec![])
    }

    pub(crate) fn display_help_error(cmd: &Command, colorizer: Colorizer) -> Self {
        Self::for_app(
            ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand,
            cmd,
            colorizer,
            vec![],
        )
    }

    pub(crate) fn display_version(cmd: &Command, colorizer: Colorizer) -> Self {
        Self::for_app(ErrorKind::DisplayVersion, cmd, colorizer, vec![])
    }

    pub(crate) fn argument_conflict(
        cmd: &Command,
        arg: String,
        mut others: Vec<String>,
        usage: String,
    ) -> Self {
        let info = others.clone();
        let others = match others.len() {
            0 => ContextValue::None,
            1 => ContextValue::String(others.pop().unwrap()),
            _ => ContextValue::Strings(others),
        };
        Self::new(ErrorKind::ArgumentConflict)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (ContextKind::PriorArg, others),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn empty_value(cmd: &Command, good_vals: &[&str], arg: String) -> Self {
        let info = vec![arg.clone()];
        let mut err = Self::new(ErrorKind::EmptyValue)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([(ContextKind::InvalidArg, ContextValue::String(arg))]);
        if !good_vals.is_empty() {
            err = err.insert_context_unchecked(
                ContextKind::ValidValue,
                ContextValue::Strings(good_vals.iter().map(|s| (*s).to_owned()).collect()),
            );
        }
        err
    }

    pub(crate) fn no_equals(cmd: &Command, arg: String, usage: String) -> Self {
        let info = vec![arg.clone()];
        Self::new(ErrorKind::NoEquals)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn invalid_value(
        cmd: &Command,
        bad_val: String,
        good_vals: &[&str],
        arg: String,
    ) -> Self {
        let mut info = vec![arg.clone(), bad_val.clone()];
        info.extend(good_vals.iter().map(|s| (*s).to_owned()));

        let suggestion = suggestions::did_you_mean(&bad_val, good_vals.iter()).pop();
        let mut err = Self::new(ErrorKind::InvalidValue)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (ContextKind::InvalidValue, ContextValue::String(bad_val)),
                (
                    ContextKind::ValidValue,
                    ContextValue::Strings(good_vals.iter().map(|s| (*s).to_owned()).collect()),
                ),
            ]);
        if let Some(suggestion) = suggestion {
            err = err.insert_context_unchecked(
                ContextKind::SuggestedValue,
                ContextValue::String(suggestion),
            );
        }
        err
    }

    pub(crate) fn invalid_subcommand(
        cmd: &Command,
        subcmd: String,
        did_you_mean: String,
        name: String,
        usage: String,
    ) -> Self {
        let info = vec![subcmd.clone()];
        let suggestion = format!("{} -- {}", name, subcmd);
        Self::new(ErrorKind::InvalidSubcommand)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidSubcommand, ContextValue::String(subcmd)),
                (
                    ContextKind::SuggestedSubcommand,
                    ContextValue::String(did_you_mean),
                ),
                (
                    ContextKind::SuggestedCommand,
                    ContextValue::String(suggestion),
                ),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn unrecognized_subcommand(cmd: &Command, subcmd: String, usage: String) -> Self {
        let info = vec![subcmd.clone()];
        Self::new(ErrorKind::UnrecognizedSubcommand)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidSubcommand, ContextValue::String(subcmd)),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn missing_required_argument(
        cmd: &Command,
        required: Vec<String>,
        usage: String,
    ) -> Self {
        let info = required.clone();
        Self::new(ErrorKind::MissingRequiredArgument)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::Strings(required)),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn missing_subcommand(cmd: &Command, name: String, usage: String) -> Self {
        let info = vec![];
        Self::new(ErrorKind::MissingSubcommand)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidSubcommand, ContextValue::String(name)),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn invalid_utf8(cmd: &Command, usage: String) -> Self {
        let info = vec![];
        Self::new(ErrorKind::InvalidUtf8)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([(ContextKind::Usage, ContextValue::String(usage))])
    }

    pub(crate) fn too_many_occurrences(
        cmd: &Command,
        arg: String,
        max_occurs: usize,
        curr_occurs: usize,
        usage: String,
    ) -> Self {
        let info = vec![arg.clone(), curr_occurs.to_string(), max_occurs.to_string()];
        Self::new(ErrorKind::TooManyOccurrences)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (
                    ContextKind::MaxOccurrences,
                    ContextValue::Number(max_occurs as isize),
                ),
                (
                    ContextKind::ActualNumValues,
                    ContextValue::Number(curr_occurs as isize),
                ),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn too_many_values(cmd: &Command, val: String, arg: String, usage: String) -> Self {
        let info = vec![arg.clone(), val.clone()];
        Self::new(ErrorKind::TooManyValues)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (ContextKind::InvalidValue, ContextValue::String(val)),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn too_few_values(
        cmd: &Command,
        arg: String,
        min_vals: usize,
        curr_vals: usize,
        usage: String,
    ) -> Self {
        let info = vec![arg.clone(), curr_vals.to_string(), min_vals.to_string()];
        Self::new(ErrorKind::TooFewValues)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (
                    ContextKind::MinValues,
                    ContextValue::Number(min_vals as isize),
                ),
                (
                    ContextKind::ActualNumValues,
                    ContextValue::Number(curr_vals as isize),
                ),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn value_validation(
        arg: String,
        val: String,
        err: Box<dyn error::Error + Send + Sync>,
    ) -> Self {
        let info = vec![arg.clone(), val.to_string(), err.to_string()];
        Self::new(ErrorKind::ValueValidation)
            .set_info(info)
            .set_source(err)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (ContextKind::InvalidValue, ContextValue::String(val)),
            ])
    }

    pub(crate) fn wrong_number_of_values(
        cmd: &Command,
        arg: String,
        num_vals: usize,
        curr_vals: usize,
        usage: String,
    ) -> Self {
        let info = vec![arg.clone(), curr_vals.to_string(), num_vals.to_string()];
        Self::new(ErrorKind::WrongNumberOfValues)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (
                    ContextKind::ExpectedNumValues,
                    ContextValue::Number(num_vals as isize),
                ),
                (
                    ContextKind::ActualNumValues,
                    ContextValue::Number(curr_vals as isize),
                ),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn unexpected_multiple_usage(cmd: &Command, arg: String, usage: String) -> Self {
        let info = vec![arg.clone()];
        Self::new(ErrorKind::UnexpectedMultipleUsage)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn unknown_argument(
        cmd: &Command,
        arg: String,
        did_you_mean: Option<(String, Option<String>)>,
        usage: String,
    ) -> Self {
        let info = vec![arg.clone()];
        let mut err = Self::new(ErrorKind::UnknownArgument)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (ContextKind::Usage, ContextValue::String(usage)),
            ]);
        if let Some((flag, sub)) = did_you_mean {
            err = err.insert_context_unchecked(
                ContextKind::SuggestedArg,
                ContextValue::String(format!("--{}", flag)),
            );
            if let Some(sub) = sub {
                err = err.insert_context_unchecked(
                    ContextKind::SuggestedSubcommand,
                    ContextValue::String(sub),
                );
            }
        }
        err
    }

    pub(crate) fn unnecessary_double_dash(cmd: &Command, arg: String, usage: String) -> Self {
        let info = vec![arg.clone()];
        Self::new(ErrorKind::UnknownArgument)
            .with_cmd(cmd)
            .set_info(info)
            .extend_context_unchecked([
                (ContextKind::InvalidArg, ContextValue::String(arg)),
                (ContextKind::TrailingArg, ContextValue::Bool(true)),
                (ContextKind::Usage, ContextValue::String(usage)),
            ])
    }

    pub(crate) fn argument_not_found_auto(arg: String) -> Self {
        let info = vec![arg.clone()];
        Self::new(ErrorKind::ArgumentNotFound)
            .set_info(info)
            .extend_context_unchecked([(ContextKind::InvalidArg, ContextValue::String(arg))])
    }

    fn formatted(&self) -> Cow<'_, Colorizer> {
        if let Some(message) = self.inner.message.as_ref() {
            message.formatted()
        } else {
            let mut c = Colorizer::new(self.stream(), self.inner.color_when);

            start_error(&mut c);

            if !self.write_dynamic_context(&mut c) {
                if let Some(msg) = self.kind().as_str() {
                    c.none(msg.to_owned());
                } else if let Some(source) = self.inner.source.as_ref() {
                    c.none(source.to_string());
                } else {
                    c.none("Unknown cause");
                }
            }

            let usage = self.get_context(ContextKind::Usage);
            if let Some(ContextValue::String(usage)) = usage {
                put_usage(&mut c, usage);
            }

            try_help(&mut c, self.inner.help_flag);

            Cow::Owned(c)
        }
    }

    #[must_use]
    fn write_dynamic_context(&self, c: &mut Colorizer) -> bool {
        match self.kind() {
            ErrorKind::ArgumentConflict => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                let prior_arg = self.get_context(ContextKind::PriorArg);
                if let (Some(ContextValue::String(invalid_arg)), Some(prior_arg)) =
                    (invalid_arg, prior_arg)
                {
                    c.none("The argument '");
                    c.warning(invalid_arg);
                    c.none("' cannot be used with");

                    match prior_arg {
                        ContextValue::Strings(values) => {
                            c.none(":");
                            for v in values {
                                c.none("\n    ");
                                c.warning(&**v);
                            }
                        }
                        ContextValue::String(value) => {
                            c.none(" '");
                            c.warning(value);
                            c.none("'");
                        }
                        _ => {
                            c.none(" one or more of the other specified arguments");
                        }
                    }
                    true
                } else {
                    false
                }
            }
            ErrorKind::EmptyValue => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
                    c.none("The argument '");
                    c.warning(invalid_arg);
                    c.none("' requires a value but none was supplied");

                    let possible_values = self.get_context(ContextKind::ValidValue);
                    if let Some(ContextValue::Strings(possible_values)) = possible_values {
                        c.none("\n\t[possible values: ");
                        if let Some((last, elements)) = possible_values.split_last() {
                            for v in elements {
                                c.good(escape(v));
                                c.none(", ");
                            }
                            c.good(escape(last));
                        }
                        c.none("]");
                    }
                    true
                } else {
                    false
                }
            }
            ErrorKind::NoEquals => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
                    c.none("Equal sign is needed when assigning values to '");
                    c.warning(invalid_arg);
                    c.none("'.");
                    true
                } else {
                    false
                }
            }
            ErrorKind::InvalidValue => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                let invalid_value = self.get_context(ContextKind::InvalidValue);
                if let (
                    Some(ContextValue::String(invalid_arg)),
                    Some(ContextValue::String(invalid_value)),
                ) = (invalid_arg, invalid_value)
                {
                    c.none(quote(invalid_value));
                    c.none(" isn't a valid value for '");
                    c.warning(invalid_arg);
                    c.none("'");

                    let possible_values = self.get_context(ContextKind::ValidValue);
                    if let Some(ContextValue::Strings(possible_values)) = possible_values {
                        c.none("\n\t[possible values: ");
                        if let Some((last, elements)) = possible_values.split_last() {
                            for v in elements {
                                c.good(escape(v));
                                c.none(", ");
                            }
                            c.good(escape(last));
                        }
                        c.none("]");
                    }

                    let suggestion = self.get_context(ContextKind::SuggestedValue);
                    if let Some(ContextValue::String(suggestion)) = suggestion {
                        c.none("\n\n\tDid you mean ");
                        c.good(quote(suggestion));
                        c.none("?");
                    }
                    true
                } else {
                    false
                }
            }
            ErrorKind::InvalidSubcommand => {
                let invalid_sub = self.get_context(ContextKind::InvalidSubcommand);
                if let Some(ContextValue::String(invalid_sub)) = invalid_sub {
                    c.none("The subcommand '");
                    c.warning(invalid_sub);
                    c.none("' wasn't recognized");

                    let valid_sub = self.get_context(ContextKind::SuggestedSubcommand);
                    if let Some(ContextValue::String(valid_sub)) = valid_sub {
                        c.none("\n\n\tDid you mean ");
                        c.good(valid_sub);
                        c.none("?");
                    }

                    let suggestion = self.get_context(ContextKind::SuggestedCommand);
                    if let Some(ContextValue::String(suggestion)) = suggestion {
                        c.none(
            "\n\nIf you believe you received this message in error, try re-running with '",
        );
                        c.good(suggestion);
                        c.none("'");
                    }
                    true
                } else {
                    false
                }
            }
            ErrorKind::UnrecognizedSubcommand => {
                let invalid_sub = self.get_context(ContextKind::InvalidSubcommand);
                if let Some(ContextValue::String(invalid_sub)) = invalid_sub {
                    c.none("The subcommand '");
                    c.warning(invalid_sub);
                    c.none("' wasn't recognized");
                    true
                } else {
                    false
                }
            }
            ErrorKind::MissingRequiredArgument => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                if let Some(ContextValue::Strings(invalid_arg)) = invalid_arg {
                    c.none("The following required arguments were not provided:");
                    for v in invalid_arg {
                        c.none("\n    ");
                        c.good(&**v);
                    }
                    true
                } else {
                    false
                }
            }
            ErrorKind::MissingSubcommand => {
                let invalid_sub = self.get_context(ContextKind::InvalidSubcommand);
                if let Some(ContextValue::String(invalid_sub)) = invalid_sub {
                    c.none("'");
                    c.warning(invalid_sub);
                    c.none("' requires a subcommand but one was not provided");
                    true
                } else {
                    false
                }
            }
            ErrorKind::InvalidUtf8 => false,
            ErrorKind::TooManyOccurrences => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                let actual_num_occurs = self.get_context(ContextKind::ActualNumOccurrences);
                let max_occurs = self.get_context(ContextKind::MaxOccurrences);
                if let (
                    Some(ContextValue::String(invalid_arg)),
                    Some(ContextValue::Number(actual_num_occurs)),
                    Some(ContextValue::Number(max_occurs)),
                ) = (invalid_arg, actual_num_occurs, max_occurs)
                {
                    let were_provided = Error::singular_or_plural(*actual_num_occurs as usize);
                    c.none("The argument '");
                    c.warning(invalid_arg);
                    c.none("' allows at most ");
                    c.warning(max_occurs.to_string());
                    c.none(" occurrences but ");
                    c.warning(actual_num_occurs.to_string());
                    c.none(were_provided);
                    true
                } else {
                    false
                }
            }
            ErrorKind::TooManyValues => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                let invalid_value = self.get_context(ContextKind::InvalidValue);
                if let (
                    Some(ContextValue::String(invalid_arg)),
                    Some(ContextValue::String(invalid_value)),
                ) = (invalid_arg, invalid_value)
                {
                    c.none("The value '");
                    c.warning(invalid_value);
                    c.none("' was provided to '");
                    c.warning(invalid_arg);
                    c.none("' but it wasn't expecting any more values");
                    true
                } else {
                    false
                }
            }
            ErrorKind::TooFewValues => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                let actual_num_values = self.get_context(ContextKind::ActualNumValues);
                let min_values = self.get_context(ContextKind::MinValues);
                if let (
                    Some(ContextValue::String(invalid_arg)),
                    Some(ContextValue::Number(actual_num_values)),
                    Some(ContextValue::Number(min_values)),
                ) = (invalid_arg, actual_num_values, min_values)
                {
                    let were_provided = Error::singular_or_plural(*actual_num_values as usize);
                    c.none("The argument '");
                    c.warning(invalid_arg);
                    c.none("' requires at least ");
                    c.warning(min_values.to_string());
                    c.none(" values but only ");
                    c.warning(actual_num_values.to_string());
                    c.none(were_provided);
                    true
                } else {
                    false
                }
            }
            ErrorKind::ValueValidation => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                let invalid_value = self.get_context(ContextKind::InvalidValue);
                if let (
                    Some(ContextValue::String(invalid_arg)),
                    Some(ContextValue::String(invalid_value)),
                ) = (invalid_arg, invalid_value)
                {
                    c.none("Invalid value ");
                    c.warning(quote(invalid_value));
                    c.none(" for '");
                    c.warning(invalid_arg);
                    if let Some(source) = self.inner.source.as_deref() {
                        c.none("': ");
                        c.none(source.to_string());
                    } else {
                        c.none("'");
                    }
                    true
                } else {
                    false
                }
            }
            ErrorKind::WrongNumberOfValues => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                let actual_num_values = self.get_context(ContextKind::ActualNumValues);
                let num_values = self.get_context(ContextKind::ExpectedNumValues);
                if let (
                    Some(ContextValue::String(invalid_arg)),
                    Some(ContextValue::Number(actual_num_values)),
                    Some(ContextValue::Number(num_values)),
                ) = (invalid_arg, actual_num_values, num_values)
                {
                    let were_provided = Error::singular_or_plural(*actual_num_values as usize);
                    c.none("The argument '");
                    c.warning(invalid_arg);
                    c.none("' requires ");
                    c.warning(num_values.to_string());
                    c.none(" values, but ");
                    c.warning(actual_num_values.to_string());
                    c.none(were_provided);
                    true
                } else {
                    false
                }
            }
            ErrorKind::UnexpectedMultipleUsage => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
                    c.none("The argument '");
                    c.warning(invalid_arg.to_string());
                    c.none("' was provided more than once, but cannot be used multiple times");
                    true
                } else {
                    false
                }
            }
            ErrorKind::UnknownArgument => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
                    c.none("Found argument '");
                    c.warning(invalid_arg.to_string());
                    c.none("' which wasn't expected, or isn't valid in this context");

                    let valid_sub = self.get_context(ContextKind::SuggestedSubcommand);
                    let valid_arg = self.get_context(ContextKind::SuggestedArg);
                    match (valid_sub, valid_arg) {
                        (
                            Some(ContextValue::String(valid_sub)),
                            Some(ContextValue::String(valid_arg)),
                        ) => {
                            c.none("\n\n\tDid you mean ");
                            c.none("to put '");
                            c.good(valid_arg);
                            c.none("' after the subcommand '");
                            c.good(valid_sub);
                            c.none("'?");
                        }
                        (None, Some(ContextValue::String(valid_arg))) => {
                            c.none("\n\n\tDid you mean '");
                            c.good(valid_arg);
                            c.none("'?");
                        }
                        (_, _) => {}
                    }

                    let invalid_arg = self.get_context(ContextKind::InvalidArg);
                    if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
                        if invalid_arg.starts_with('-') {
                            c.none(format!(
                                "\n\n\tIf you tried to supply `{}` as a value rather than a flag, use `-- {}`",
                                invalid_arg, invalid_arg
                            ));
                        }

                        let trailing_arg = self.get_context(ContextKind::TrailingArg);
                        if trailing_arg == Some(&ContextValue::Bool(true)) {
                            c.none(format!(
                            "\n\n\tIf you tried to supply `{}` as a subcommand, remove the '--' before it.",
                            invalid_arg
                        ));
                        }
                    }
                    true
                } else {
                    false
                }
            }
            ErrorKind::ArgumentNotFound => {
                let invalid_arg = self.get_context(ContextKind::InvalidArg);
                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
                    c.none("The argument '");
                    c.warning(invalid_arg.to_string());
                    c.none("' wasn't found");
                    true
                } else {
                    false
                }
            }
            ErrorKind::DisplayHelp
            | ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
            | ErrorKind::DisplayVersion
            | ErrorKind::Io
            | ErrorKind::Format => false,
        }
    }

    /// Returns the singular or plural form on the verb to be based on the argument's value.
    fn singular_or_plural(n: usize) -> &'static str {
        if n > 1 {
            " were provided"
        } else {
            " was provided"
        }
    }
}

impl From<io::Error> for Error {
    fn from(e: io::Error) -> Self {
        Error::raw(ErrorKind::Io, e)
    }
}

impl From<fmt::Error> for Error {
    fn from(e: fmt::Error) -> Self {
        Error::raw(ErrorKind::Format, e)
    }
}

impl error::Error for Error {
    #[allow(trivial_casts)]
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        self.inner.source.as_ref().map(|e| e.as_ref() as _)
    }
}

impl Display for Error {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        // Assuming `self.message` already has a trailing newline, from `try_help` or similar
        write!(f, "{}", self.formatted())?;
        if let Some(backtrace) = self.inner.backtrace.as_ref() {
            writeln!(f)?;
            writeln!(f, "Backtrace:")?;
            writeln!(f, "{}", backtrace)?;
        }
        Ok(())
    }
}

fn start_error(c: &mut Colorizer) {
    c.error("error:");
    c.none(" ");
}

fn put_usage(c: &mut Colorizer, usage: impl Into<String>) {
    c.none("\n\n");
    c.none(usage);
}

fn get_help_flag(cmd: &Command) -> Option<&'static str> {
    if !cmd.is_disable_help_flag_set() {
        Some("--help")
    } else if cmd.has_subcommands() && !cmd.is_disable_help_subcommand_set() {
        Some("help")
    } else {
        None
    }
}

fn try_help(c: &mut Colorizer, help: Option<&str>) {
    if let Some(help) = help {
        c.none("\n\nFor more information try ");
        c.good(help);
        c.none("\n");
    } else {
        c.none("\n");
    }
}

fn quote(s: impl AsRef<str>) -> String {
    let s = s.as_ref();
    format!("{:?}", s)
}

fn escape(s: impl AsRef<str>) -> String {
    let s = s.as_ref();
    if s.contains(char::is_whitespace) {
        quote(s)
    } else {
        s.to_owned()
    }
}

#[derive(Clone, Debug)]
pub(crate) enum Message {
    Raw(String),
    Formatted(Colorizer),
}

impl Message {
    fn format(&mut self, cmd: &Command, usage: String) {
        match self {
            Message::Raw(s) => {
                let mut c = Colorizer::new(Stream::Stderr, cmd.get_color());

                let mut message = String::new();
                std::mem::swap(s, &mut message);
                start_error(&mut c);
                c.none(message);
                put_usage(&mut c, usage);
                try_help(&mut c, get_help_flag(cmd));
                *self = Self::Formatted(c);
            }
            Message::Formatted(_) => {}
        }
    }

    fn formatted(&self) -> Cow<Colorizer> {
        match self {
            Message::Raw(s) => {
                let mut c = Colorizer::new(Stream::Stderr, ColorChoice::Never);
                start_error(&mut c);
                c.none(s);
                Cow::Owned(c)
            }
            Message::Formatted(c) => Cow::Borrowed(c),
        }
    }
}

impl From<String> for Message {
    fn from(inner: String) -> Self {
        Self::Raw(inner)
    }
}

impl From<Colorizer> for Message {
    fn from(inner: Colorizer) -> Self {
        Self::Formatted(inner)
    }
}

#[cfg(feature = "debug")]
#[derive(Debug)]
struct Backtrace(backtrace::Backtrace);

#[cfg(feature = "debug")]
impl Backtrace {
    fn new() -> Option<Self> {
        Some(Self(backtrace::Backtrace::new()))
    }
}

#[cfg(feature = "debug")]
impl Display for Backtrace {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        // `backtrace::Backtrace` uses `Debug` instead of `Display`
        write!(f, "{:?}", self.0)
    }
}

#[cfg(not(feature = "debug"))]
#[derive(Debug)]
struct Backtrace;

#[cfg(not(feature = "debug"))]
impl Backtrace {
    fn new() -> Option<Self> {
        None
    }
}

#[cfg(not(feature = "debug"))]
impl Display for Backtrace {
    fn fmt(&self, _: &mut Formatter) -> fmt::Result {
        Ok(())
    }
}

#[test]
fn check_auto_traits() {
    static_assertions::assert_impl_all!(Error: Send, Sync, Unpin);
}