use std::fmt;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum OrchestrationErrorKind {
    InvalidInput,
    InvalidLimits,
    EmptyProposal,
    DuplicateTask,
    DuplicateDependency,
    DuplicateEdge,
    UnknownDependency,
    SelfDependency,
    Cycle,
    UnknownAgent,
    UnknownTask,
    ExistingTaskMutation,
    NodeBudgetExceeded,
    EdgeBudgetExceeded,
    DepthBudgetExceeded,
    FanOutBudgetExceeded,
    ConflictingTaskSet,
    UnsatisfiedDependency,
}

#[allow(non_upper_case_globals)]
impl OrchestrationErrorKind {
    /// Compatibility alias for callers that describe the node budget as a
    /// task budget.
    pub const TaskBudgetExceeded: Self = Self::NodeBudgetExceeded;

    /// Compatibility alias for callers that use the shorter fan-out spelling.
    pub const FanoutBudgetExceeded: Self = Self::FanOutBudgetExceeded;
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct OrchestrationError {
    kind: OrchestrationErrorKind,
    detail: String,
}

impl OrchestrationError {
    pub(crate) fn new(kind: OrchestrationErrorKind, detail: impl Into<String>) -> Self {
        Self {
            kind,
            detail: detail.into(),
        }
    }

    pub fn kind(&self) -> OrchestrationErrorKind {
        self.kind
    }

    pub fn detail(&self) -> &str {
        &self.detail
    }
}

impl fmt::Display for OrchestrationError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(&self.detail)
    }
}

impl std::error::Error for OrchestrationError {}