use crate::resolver::ResolverError;
use miette::Diagnostic;
use smol_str::SmolStr;
use thiserror::Error;

#[derive(Debug, Diagnostic, Error)]
pub enum BackfillError {
    #[error("{0}")]
    Generic(miette::Report),
    #[error("too many requests")]
    Ratelimited,
    #[error("pds is throttled")]
    PreemptivelyThrottled,
    #[error("pds endpoint is permanently unsafe: {0}")]
    UnsafeEndpoint(SmolStr),
    #[error("pds backfill slots are busy")]
    PdsBusy,
    #[error("transport error: {0}")]
    Transport(SmolStr),
    #[error("repo was concurrently deleted")]
    Deleted,
    #[error("getRepo returned RepoNotFound")]
    RepoNotFound,
}



impl From<miette::Report> for BackfillError {
    fn from(e: miette::Report) -> Self {
        Self::Generic(e)
    }
}

impl From<ResolverError> for BackfillError {
    fn from(e: ResolverError) -> Self {
        match e {
            ResolverError::Ratelimited => Self::Ratelimited,
            ResolverError::Transport(s) => Self::Transport(s),
            ResolverError::HandleResolutionExhausted(e) | ResolverError::Generic(e) => {
                Self::Generic(e)
            }
            error @ (ResolverError::MissingPds(_)
            | ResolverError::NotFound(_)
            | ResolverError::NoSigningKey(_)) => Self::Generic(error.into()),
        }
    }
}

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

    #[test]
    fn exhausted_handle_resolution_is_not_a_backfill_transport_failure() {
        let error = BackfillError::from(ResolverError::HandleResolutionExhausted(miette::miette!(
            "handle not found"
        )));
        assert!(matches!(error, BackfillError::Generic(_)));
    }
}