use std::time::Duration;

/// `Backoff` is a backoff policy for retrying an operation.
pub trait Backoff {
    /// Resets the internal state to the initial value.
    fn reset(&mut self) {}
    /// next_backoff() time is elapsed before it is called again.
    /// If it returns None, it means the operation timed out and no
    /// further retries are done.
    fn next_backoff(&mut self) -> Option<Duration>;
}

impl<B: Backoff + ?Sized> Backoff for Box<B> {
    fn next_backoff(&mut self) -> Option<Duration> {
        let this: &mut B = self;
        this.next_backoff()
    }

    fn reset(&mut self) {
        let this: &mut B = self;
        this.reset()
    }
}

/// Immediately retry the operation.
#[derive(Debug)]
pub struct Zero {}

impl Backoff for Zero {
    fn next_backoff(&mut self) -> Option<Duration> {
        Some(Duration::default())
    }
}

/// The operation should never be retried.
#[derive(Debug)]
pub struct Stop {}

impl Backoff for Stop {
    fn next_backoff(&mut self) -> Option<Duration> {
        None
    }
}

/// Contant is a backoff policy which always returns
/// a constant duration.
#[derive(Debug)]
pub struct Constant {
    interval: Duration,
}

impl Constant {
    /// Creates a new Constant backoff with `interval` contant
    /// backoff.
    pub fn new(interval: Duration) -> Constant {
        Constant { interval }
    }
}

impl Backoff for Constant {
    fn next_backoff(&mut self) -> Option<Duration> {
        Some(self.interval)
    }
}