//! CLI errors and exit codes (PLAN 6.15: 0 ok, 1 error, 2 usage, 3 conflicts, 4 dirty refusal).

use scion_core::{ErrorCode, ScionError};
use scion_wc::WorkingCopy;

/// Exit code: success.
pub(crate) const EXIT_OK: i32 = 0;
/// Exit code: any other error.
pub(crate) const EXIT_ERROR: i32 = 1;
/// Exit code: usage error.
pub(crate) const EXIT_USAGE: i32 = 2;
/// Exit code: merge conflicts (rebase paused, unresolved conflicts).
pub(crate) const EXIT_CONFLICTS: i32 = 3;
/// Exit code: refused because of dirty files.
pub(crate) const EXIT_DIRTY: i32 = 4;

/// A failed command.
#[derive(Debug, thiserror::Error)]
pub(crate) enum CliError {
    /// A Scion error (from the server or the working-copy library).
    #[error("{0}")]
    Scion(#[from] ScionError),
    /// Bad command-line usage detected after parsing.
    #[error("{0}")]
    Usage(String),
    /// A client-side failure that has no SPEC error code.
    #[error("{0}")]
    Local(String),
}

pub(crate) type CliResult<T> = Result<T, CliError>;

impl CliError {
    /// PLAN 6.15 exit code.
    pub(crate) fn exit_code(&self) -> i32 {
        match self {
            CliError::Usage(_) => EXIT_USAGE,
            CliError::Local(_) => EXIT_ERROR,
            CliError::Scion(e) => scion_exit_code(e),
        }
    }

    /// `(code, subcode)` for the error envelope.
    pub(crate) fn code(&self) -> (String, Option<String>) {
        match self {
            CliError::Usage(_) => ("USAGE".to_owned(), None),
            CliError::Local(_) => ("LOCAL".to_owned(), None),
            CliError::Scion(e) => (e.code.as_str().to_owned(), e.subcode().map(str::to_owned)),
        }
    }

    /// Human message: `CODE[/subcode]: message`.
    pub(crate) fn human(&self) -> String {
        match self {
            CliError::Usage(m) => format!("usage: {m}"),
            CliError::Local(m) => m.clone(),
            CliError::Scion(e) => match e.subcode() {
                Some(s) => format!("{}/{s}: {}", e.code.as_str(), e.message),
                None => format!("{}: {}", e.code.as_str(), e.message),
            },
        }
    }

    /// The message alone.
    pub(crate) fn message(&self) -> String {
        match self {
            CliError::Usage(m) | CliError::Local(m) => m.clone(),
            CliError::Scion(e) => e.message.clone(),
        }
    }
}

/// Exit code of a Scion error (PLAN 6.15).
pub(crate) fn scion_exit_code(e: &ScionError) -> i32 {
    if e.code == ErrorCode::MergeConflict {
        return EXIT_CONFLICTS;
    }
    match e.subcode() {
        Some(s) if s == WorkingCopy::SUBCODE_DIRTY => EXIT_DIRTY,
        Some(s)
            if s == WorkingCopy::SUBCODE_UNRESOLVED || s == WorkingCopy::SUBCODE_MARKERS_REMAIN =>
        {
            EXIT_CONFLICTS
        }
        _ => EXIT_ERROR,
    }
}

/// A local error.
pub(crate) fn local(msg: impl Into<String>) -> CliError {
    CliError::Local(msg.into())
}

/// A usage error.
pub(crate) fn usage(msg: impl Into<String>) -> CliError {
    CliError::Usage(msg.into())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn exit_codes() {
        assert_eq!(usage("x").exit_code(), EXIT_USAGE);
        assert_eq!(local("x").exit_code(), EXIT_ERROR);
        let c = CliError::from(ScionError::new(ErrorCode::MergeConflict, "c"));
        assert_eq!(c.exit_code(), EXIT_CONFLICTS);
        let d = CliError::from(ScionError::invalid(WorkingCopy::SUBCODE_DIRTY, "d"));
        assert_eq!(d.exit_code(), EXIT_DIRTY);
        assert_eq!(
            d.code(),
            (
                "INVALID_ARGUMENT".into(),
                Some(WorkingCopy::SUBCODE_DIRTY.into())
            )
        );
        let m = CliError::from(ScionError::invalid(
            WorkingCopy::SUBCODE_MARKERS_REMAIN,
            "m",
        ));
        assert_eq!(m.exit_code(), EXIT_CONFLICTS);
        let u = CliError::from(ScionError::invalid(WorkingCopy::SUBCODE_UNRESOLVED, "u"));
        assert_eq!(u.exit_code(), EXIT_CONFLICTS);
        let n = CliError::from(ScionError::not_found("n"));
        assert_eq!(n.exit_code(), EXIT_ERROR);
        assert!(n.human().starts_with("NOT_FOUND: "));
    }
}