/// Snooze is a crate that allows you to trigger the sending of a message with a specific delay or
/// interval. This is usefull to handle TTL for example.
/// 
/// ## Usage
/// 
/// Basically, you just need to instanciate an instance of a `Notifier`, to which you register events to trigger
/// at a certain time:
/// 
/// ```rust
/// let mut notifier = Nofifier::new();
/// // do not drop the handle
/// notifier.notify_afer(Duration::from_secs(1), "world");
/// let _handle = notifier.notify_interval(Duration::from_secs(2), "hello");
/// 
/// assert_eq!(notifier.next().await, Some("hello"));
/// assert_eq!(notifier.next().await, Some("world"));
/// assert_eq!(notifier.next().await, Some("hello"));
/// ```
///
use std::time::Duration;

use tokio::sync::{mpsc, oneshot};
use tokio::time;

pub struct Nofifier<T> {
    sender: mpsc::UnboundedSender<T>,
    receiver: mpsc::UnboundedReceiver<T>
}

impl<T: Sync + Send + 'static> Nofifier<T> {
    pub fn new() -> Self {
        let (sender, receiver) = mpsc::unbounded_channel();
        Self { sender, receiver }
    }

    pub fn notify_afer(&self, duration: Duration, message: T) {
        let sender = self.sender.clone();
        tokio::spawn(async move {
            time::sleep(duration).await;
            let _ =  sender.clone().send(message);
        });
    }

    pub async fn next(&mut self) -> Option<T> {
        self.receiver.recv().await
    }
}

pub struct NotifyIntervalHandle(oneshot::Sender<()>);

impl NotifyIntervalHandle {
    pub fn close(self) { }
}

impl<T: Sync + Send + 'static + Clone> Nofifier<T> {
    /// Sends a message `T` every `duration`. Returns a handle to the task that shutsdown the task
    /// on drop.
    pub fn notify_interval(&self, duration: Duration, message: T) -> NotifyIntervalHandle {
        let sender = self.sender.clone();
        let (tx, mut rx) = oneshot::channel();
        tokio::spawn(async move {
            let mut interval = time::interval(duration);
            loop {
                tokio::select! {
                    _ = interval.tick() => {
                        if let Err(_) = sender.clone().send(message.clone()) {
                            break
                        }
                    }
                    _ = &mut rx => break,
                }
            }
        });
        NotifyIntervalHandle(tx)
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use std::time::Duration;

    #[tokio::test]
    async fn test_notify_after() {
        let mut notifier = Nofifier::new();
        notifier.notify_afer(Duration::from_secs(2), "hello");
        notifier.notify_afer(Duration::from_secs(1), "world");

        assert_eq!(notifier.next().await, Some("world"));
        assert_eq!(notifier.next().await, Some("hello"));
    }

    #[tokio::test]
    async fn test_notify_interfal() {
        let mut notifier = Nofifier::new();
        // do not drop the handle
        let _handle = notifier.notify_interval(Duration::from_secs(1), "hello");

        assert_eq!(notifier.next().await, Some("hello"));
        assert_eq!(notifier.next().await, Some("hello"));
    }

    #[tokio::test]
    async fn test_mixed() {
        let mut notifier = Nofifier::new();
        // do not drop the handle
        notifier.notify_afer(Duration::from_secs(1), "world");
        let _handle = notifier.notify_interval(Duration::from_secs(2), "hello");

        assert_eq!(notifier.next().await, Some("hello"));
        assert_eq!(notifier.next().await, Some("world"));
        assert_eq!(notifier.next().await, Some("hello"));
    }
}