use alloc::{boxed::Box, string::String};

use crate::{Backtrace, ChainCompat, Snafu};

/// A basic error type that you can use as a first step to better
/// error handling.
///
/// You can use this type in your own application as a quick way to
/// create errors or add basic context to another error. This can also
/// be used in a library, but consider wrapping it in an
/// [opaque](crate::guide::opaque) error to avoid putting the SNAFU
/// crate in your public API.
///
/// ## Examples
///
/// ```rust
/// use snafu::prelude::*;
///
/// type Result<T, E = snafu::Whatever> = std::result::Result<T, E>;
///
/// fn subtract_numbers(a: u32, b: u32) -> Result<u32> {
///     if a > b {
///         Ok(a - b)
///     } else {
///         whatever!("Can't subtract {a} - {b}")
///     }
/// }
///
/// fn complicated_math(a: u32, b: u32) -> Result<u32> {
///     let val = subtract_numbers(a, b).whatever_context("Can't do the math")?;
///     Ok(val * 2)
/// }
/// ```
///
/// See [`whatever!`][crate::whatever!] for detailed usage instructions.
///
/// ## Limitations
///
/// When wrapping errors, only the backtrace from the shallowest
/// function is guaranteed to be available. If you need the deepest
/// possible trace, consider creating a custom error type and [using
/// `#[snafu(backtrace)]` on the `source`
/// field](Snafu#controlling-backtraces). If a best-effort attempt is
/// sufficient, see the [`backtrace`][Self::backtrace] method.
///
/// When the standard library stabilizes support for the
/// [provide API](https://doc.rust-lang.org/std/error/trait.Error.html#method.provide),
/// this behavior may change.
///
/// ## Thread Safety
///
/// This type requires that contained errors implement [`Send`][] and
/// [`Sync`][]. If this is burdensome, you may also use
/// [`WhateverLocal`][].
#[derive(Debug, Snafu)]
#[snafu(crate_root(crate))]
#[snafu(whatever)]
#[snafu(display("{message}"))]
pub struct Whatever {
    #[snafu(source(from(Box<dyn crate::Error + Send + Sync>, Some)))]
    source: Option<Box<dyn crate::Error + Send + Sync>>,
    message: String,
    backtrace: Backtrace,
}

impl Whatever {
    /// Gets the backtrace from the deepest [`Whatever`][] or
    /// [`WhateverLocal`][] error. If none of the underlying errors
    /// are one of these types, returns the backtrace from when this
    /// instance was created.
    pub fn backtrace(&self) -> &Backtrace {
        known_whatevers_backtrace(self).unwrap_or(&self.backtrace)
    }
}

/// A basic error type that you can use as a first step to better
/// error handling when the error does not need to cross a thread
/// boundary.
///
/// This type behaves the same as [`Whatever`][] except it does not
/// require that the wrapped errors implement [`Send`][] or
/// [`Sync`][]. See [`Whatever`][] and [`whatever!`][crate::whatever!] for detailed
/// usage instructions.
#[derive(Debug, Snafu)]
#[snafu(crate_root(crate))]
#[snafu(whatever)]
#[snafu(display("{message}"))]
pub struct WhateverLocal {
    #[snafu(source(from(Box<dyn crate::Error>, Some)))]
    source: Option<Box<dyn crate::Error>>,
    message: String,
    backtrace: Backtrace,
}

impl WhateverLocal {
    /// Gets the backtrace from the deepest [`Whatever`][] or
    /// [`WhateverLocal`][] error. If none of the underlying errors
    /// are one of these types, returns the backtrace from when this
    /// instance was created.
    pub fn backtrace(&self) -> &Backtrace {
        known_whatevers_backtrace(self).unwrap_or(&self.backtrace)
    }
}

fn known_whatevers_backtrace<'a>(
    root: &'a (dyn crate::Error + 'static),
) -> Option<&'a crate::Backtrace> {
    ChainCompat::new(root)
        .skip(1)
        .filter_map(|e| {
            if let Some(e) = e.downcast_ref::<Whatever>() {
                Some(&e.backtrace)
            } else if let Some(e) = e.downcast_ref::<WhateverLocal>() {
                Some(&e.backtrace)
            } else {
                None
            }
        })
        .last()
}
