win-events 0.0.2

use std::collections::LinkedList;
use std::error::Error;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
use std::time::Duration;

use crate::events::event::{EventHandle, EventState};
use crate::waiters::waiter::{Signaler, WaitInfo};
use crate::{wait_one, Event};

struct WaitPair {
    set: LinkedList<WaitInfo>,
    not: LinkedList<WaitInfo>,
}

struct Waiters {
    pair: Mutex<WaitPair>,
}

impl Waiters {
    fn new() -> Waiters {
        let pair = WaitPair {
            set: LinkedList::new(),
            not: LinkedList::new(),
        };

        Waiters {
            pair: Mutex::new(pair),
        }
    }

    fn fire(&self) {
        let pair = match self.pair.lock() {
            Ok(pair) => pair,
            Err(_) => return,
        };

        for info in &pair.set {
            match info.signaler.fire(info.pos) {
                _ => {}
            }
        }
        for info in &pair.not {
            match info.signaler.clear(info.pos) {
                _ => {}
            }
        }
    }

    fn clear(&self) {
        let pair = match self.pair.lock() {
            Ok(pair) => pair,
            Err(_) => return,
        };

        for info in &pair.not {
            match info.signaler.fire(info.pos) {
                _ => {}
            }
        }
        for info in &pair.set {
            match info.signaler.clear(info.pos) {
                _ => {}
            }
        }
    }

    fn fire_not(&self) {
        self.clear()
    }

    fn clear_not(&self) {
        self.fire()
    }

    fn register_signaler_is_set(
        &self,
        pos: usize,
        signaler: Arc<dyn Signaler>,
    ) -> Result<(), Box<dyn Error>> {
        let mut pair = match self.pair.lock() {
            Ok(pair) => pair,
            Err(error) => {
                return Err(format!("Could not lock wait list: {}", error).into());
            }
        };

        let info = WaitInfo { pos, signaler };
        pair.set.push_back(info);

        Ok(())
    }

    fn remove_signaler_is_set(&self, signaler: &Arc<dyn Signaler>) -> Result<(), Box<dyn Error>> {
        let mut pair = match self.pair.lock() {
            Ok(pair) => pair,
            Err(error) => {
                return Err(format!("Could not lock wait list: {}", error).into());
            }
        };

        pair.set = {
            let list = pair.set.clone();
            let iter = list.into_iter();
            let filtered = iter.filter(|info| Arc::ptr_eq(&info.signaler, signaler));
            filtered.collect()
        };
        Ok(())
    }

    fn register_signaler_not_set(
        &self,
        pos: usize,
        signaler: Arc<dyn Signaler>,
    ) -> Result<(), Box<dyn Error>> {
        let mut pair = match self.pair.lock() {
            Ok(pair) => pair,
            Err(error) => {
                return Err(format!("Could not lock wait list: {}", error).into());
            }
        };

        let info = WaitInfo { pos, signaler };
        pair.not.push_back(info);

        Ok(())
    }

    fn remove_signaler_not_set(&self, signaler: &Arc<dyn Signaler>) -> Result<(), Box<dyn Error>> {
        let mut pair = match self.pair.lock() {
            Ok(pair) => pair,
            Err(error) => {
                return Err(format!("Could not lock wait list: {}", error).into());
            }
        };

        pair.not = {
            let list = pair.set.clone();
            let iter = list.into_iter();
            let filtered = iter.filter(|info| Arc::ptr_eq(&info.signaler, signaler));
            filtered.collect()
        };
        Ok(())
    }
}

struct ManualResetEventPairInfo {
    fired: AtomicBool,
    waiters: Waiters,
}

impl ManualResetEventPairInfo {
    fn new(init: bool) -> ManualResetEventPairInfo {
        ManualResetEventPairInfo {
            fired: AtomicBool::new(init),
            waiters: Waiters::new(),
        }
    }
}

struct ManualResetEventSetInfo {
    info: Arc<ManualResetEventPairInfo>,
}

impl EventState for ManualResetEventSetInfo {
    fn is_set(&self) -> bool {
        self.info.fired.load(Ordering::Relaxed)
    }

    fn set(&self) {
        self.info.fired.store(true, Ordering::Relaxed);
        self.info.waiters.fire();
    }

    fn clear(&self) {
        self.info.fired.store(false, Ordering::Relaxed);
        self.info.waiters.clear();
    }

    fn register_signaler(
        &self,
        pos: usize,
        signaler: Arc<dyn Signaler>,
    ) -> Result<(), Box<dyn Error>> {
        if self.is_set() {
            signaler.fire(pos)?
        }
        self.info.waiters.register_signaler_is_set(pos, signaler)
    }

    fn remove_signaler(&self, signaler: &Arc<dyn Signaler>) -> Result<(), Box<dyn Error>> {
        self.info.waiters.remove_signaler_is_set(signaler)
    }

    fn wake_lock(&self) -> Result<Option<MutexGuard<()>>, Box<dyn Error>> {
        Ok(None)
    }

    fn can_consume(&self) -> bool {
        self.is_set()
    }

    fn consume(&self) {}
}

struct ManualResetEventNotSetInfo {
    info: Arc<ManualResetEventPairInfo>,
}

impl EventState for ManualResetEventNotSetInfo {
    fn is_set(&self) -> bool {
        !self.info.fired.load(Ordering::Relaxed)
    }

    fn set(&self) {
        self.info.fired.store(false, Ordering::Relaxed);
        self.info.waiters.fire_not()
    }

    fn clear(&self) {
        self.info.fired.store(true, Ordering::Relaxed);
        self.info.waiters.clear_not();
    }

    fn register_signaler(
        &self,
        pos: usize,
        signaler: Arc<dyn Signaler>,
    ) -> Result<(), Box<dyn Error>> {
        if self.is_set() {
            signaler.fire(pos)?
        }
        self.info.waiters.register_signaler_not_set(pos, signaler)
    }

    fn remove_signaler(&self, signaler: &Arc<dyn Signaler>) -> Result<(), Box<dyn Error>> {
        self.info.waiters.remove_signaler_not_set(signaler)
    }

    fn wake_lock(&self) -> Result<Option<MutexGuard<()>>, Box<dyn Error>> {
        Ok(None)
    }

    fn can_consume(&self) -> bool {
        self.is_set()
    }

    fn consume(&self) {}
}

/// A ManualResetEventPair
///
/// An event represents a boolean condition that can be waited on until signaled. This allows a
/// thread to block and wait for another thread to set the event. Until the event is manually reset
/// waiting will return immediately.
///
/// # Examples
///
/// ```
/// use std::thread;
/// use std::time::Duration;
/// use win_events::{Event, ManualResetEventPair};
///
/// let evt_started = ManualResetEventPair::new(false);
/// let evt_started2 = evt_started.clone();
///
/// // spawn a thread and set the cloned event
/// thread::spawn(move|| {
///     evt_started2.set();
/// });
///
/// // Wait for the started event
/// evt_started.wait(Duration::from_millis(100)).unwrap();
/// ```
#[derive(Clone)]
pub struct ManualResetEventPair {
    pair: Arc<ManualResetEventPairInfo>,
    info: Arc<EventHandle>,
}

impl ManualResetEventPair {
    /// Creates a new ManualResetEventPair which can create events to wait on
    /// internally on both set and not set
    ///
    /// # Examples
    ///
    /// ```
    /// use win_events::ManualResetEventPair;
    ///
    /// let evt = ManualResetEventPair::new(false);
    /// ```
    pub fn new(init: bool) -> ManualResetEventPair {
        let pair = Arc::new(ManualResetEventPairInfo::new(init));
        let state: Box<dyn EventState> = Box::new(ManualResetEventSetInfo {
            info: Arc::clone(&pair),
        });
        let info = Arc::new(EventHandle::new(state));
        ManualResetEventPair { pair, info }
    }

    /// Gets the current state of the event.
    ///
    /// # Examples
    ///
    /// ```
    /// use win_events::ManualResetEventPair;
    ///
    /// let evt = ManualResetEventPair::new(true);
    /// assert!(evt.is_set())
    ///  ```
    pub fn is_set(&self) -> bool {
        self.info.is_set()
    }

    /// Sets the event and fires a signal to any threads waiting on the event.
    ///
    /// # Examples
    ///
    /// ```
    /// use win_events::ManualResetEventPair;
    ///
    /// let evt = ManualResetEventPair::new(false);
    /// evt.set();
    /// assert!(evt.is_set())
    /// ```
    pub fn set(&self) {
        self.info.set()
    }

    /// Sets the even, causing any waiting threads to receive a signal.
    ///
    /// # Examples
    ///
    /// ```
    /// use win_events::ManualResetEventPair;
    ///
    /// let evt = ManualResetEventPair::new(false);
    /// evt.clear();
    /// assert!(!evt.is_set())
    /// ```
    pub fn clear(&self) {
        self.info.clear()
    }
    /// Creates a new ManualResetEventPair and initialized the value.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread::{sleep, spawn};
    /// use std::time::Duration;
    /// use win_events::ManualResetEventPair;
    ///
    /// let evt = ManualResetEventPair::new(false);
    /// let evt_inner = evt.clone();
    ///
    /// let worker = spawn(move || {
    ///    sleep(Duration::from_millis(3));
    ///    evt_inner.set()
    /// });
    ///
    /// let wait_result = evt.wait(Duration::from_millis(100)).unwrap();
    /// assert!(wait_result);
    /// worker.join();
    /// ```
    pub fn wait(&self, dur: Duration) -> Result<bool, Box<dyn Error>> {
        wait_one(self, dur)
    }

    /// Creates an event that will wait on the state to be set
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread::{sleep, spawn};
    /// use std::time::Duration;
    /// use win_events::ManualResetEventPair;
    ///
    /// let evt = ManualResetEventPair::new(false);
    /// let event_set = evt.event_set();
    ///
    /// let worker = spawn(move || {
    ///    sleep(Duration::from_millis(3));
    ///    evt.set()
    /// });
    ///
    /// let wait_result = event_set.wait(Duration::from_millis(100)).unwrap();
    /// assert!(wait_result);
    /// worker.join();
    /// ```
    pub fn event_set(&self) -> ManualResetEventPair {
        let pair = Arc::clone(&self.pair);
        let state: Box<dyn EventState> = Box::new(ManualResetEventSetInfo {
            info: Arc::clone(&pair),
        });
        let info = Arc::new(EventHandle::new(state));
        ManualResetEventPair { pair, info }
    }

    /// Creates an event that will wait on the state to be set
    ///
    /// # Examples
    ///
    /// ```
    /// use std::thread::{sleep, spawn};
    /// use std::time::Duration;
    /// use win_events::ManualResetEventPair;
    ///
    /// let evt = ManualResetEventPair::new(true);
    /// let event_not_set = evt.event_not_set();
    ///
    /// let worker = spawn(move || {
    ///    sleep(Duration::from_millis(3));
    ///    evt.clear()
    /// });
    ///
    /// let wait_result = event_not_set.wait(Duration::from_millis(100)).unwrap();
    /// assert!(wait_result);
    /// worker.join();
    /// ```
    pub fn event_not_set(&self) -> ManualResetEventPair {
        let pair = Arc::clone(&self.pair);
        let state: Box<dyn EventState> = Box::new(ManualResetEventNotSetInfo {
            info: Arc::clone(&pair),
        });
        let info = Arc::new(EventHandle::new(state));
        ManualResetEventPair { pair, info }
    }
}

impl Event for ManualResetEventPair {
    fn handle(&self) -> &Arc<EventHandle> {
        &self.info
    }
}