use async_channel::{
    unbounded as unbounded_async, Receiver as AsyncReceiver, Sender as AsyncSender,
};
use crossbeam::channel::{unbounded, Receiver, Sender};

pub struct Channel<T> {
    pub tx: Sender<T>,
    pub rx: Receiver<T>,
}

impl<T> Channel<T> {
    pub fn new() -> Self {
        let (tx, rx) = unbounded::<T>();
        Self { tx, rx }
    }

    pub fn send(&self, msg: T) {
        self.tx.send(msg).unwrap()
    }

    pub fn recv(&self) -> T {
        self.rx.recv().unwrap()
    }

    pub fn is_empty(&self) -> bool {
        self.rx.is_empty()
    }
}

impl<T> Default for Channel<T> {
    fn default() -> Self {
        Channel::new()
    }
}

pub struct AsyncChannel<T> {
    pub tx: AsyncSender<T>,
    pub rx: AsyncReceiver<T>,
}

impl<T> AsyncChannel<T> {
    pub fn new() -> Self {
        let (tx, rx) = unbounded_async::<T>();
        Self { tx, rx }
    }

    pub async fn send(&self, msg: T) {
        self.tx.send(msg).await.unwrap()
    }

    pub async fn recv(&self) -> T {
        self.rx.recv().await.unwrap()
    }

    pub fn is_empty(&self) -> bool {
        self.rx.is_empty()
    }
}

impl<T> Default for AsyncChannel<T> {
    fn default() -> Self {
        AsyncChannel::new()
    }
}