use std::fmt;
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context as FutContext, Poll};
use std::time::Duration;
use futures::future::BoxFuture;
use futures::stream::{Stream, StreamExt};
use tokio::sync::mpsc::{
unbounded_channel,
UnboundedReceiver as Receiver,
UnboundedSender as Sender,
};
use tokio::time::{sleep, Sleep};
use crate::client::bridge::gateway::ShardMessenger;
use crate::collector::LazyArc;
use crate::model::application::interaction::message_component::MessageComponentInteraction;
macro_rules! impl_component_interaction_collector {
($($name:ident;)*) => {
$(
impl $name {
pub fn filter_limit(mut self, limit: u32) -> Self {
self.filter.as_mut().unwrap().filter_limit = Some(limit);
self
}
pub fn collect_limit(mut self, limit: u32) -> Self {
self.filter.as_mut().unwrap().collect_limit = Some(limit);
self
}
pub fn filter<F: Fn(&Arc<MessageComponentInteraction>) -> bool + 'static + Send + Sync>(mut self, function: F) -> Self {
self.filter.as_mut().unwrap().filter = Some(Arc::new(function));
self
}
pub fn author_id(mut self, author_id: impl Into<u64>) -> Self {
self.filter.as_mut().unwrap().author_id = Some(author_id.into());
self
}
pub fn message_id(mut self, message_id: impl Into<u64>) -> Self {
self.filter.as_mut().unwrap().message_id = Some(message_id.into());
self
}
pub fn guild_id(mut self, guild_id: impl Into<u64>) -> Self {
self.filter.as_mut().unwrap().guild_id = Some(guild_id.into());
self
}
pub fn channel_id(mut self, channel_id: impl Into<u64>) -> Self {
self.filter.as_mut().unwrap().channel_id = Some(channel_id.into());
self
}
pub fn timeout(mut self, duration: Duration) -> Self {
self.timeout = Some(Box::pin(sleep(duration)));
self
}
}
)*
}
}
#[derive(Clone, Debug)]
pub struct ComponentInteractionFilter {
filtered: u32,
collected: u32,
options: FilterOptions,
sender: Sender<Arc<MessageComponentInteraction>>,
}
impl ComponentInteractionFilter {
fn new(options: FilterOptions) -> (Self, Receiver<Arc<MessageComponentInteraction>>) {
let (sender, receiver) = unbounded_channel();
let filter = Self {
filtered: 0,
collected: 0,
sender,
options,
};
(filter, receiver)
}
pub(crate) fn send_interaction(
&mut self,
interaction: &mut LazyArc<'_, MessageComponentInteraction>,
) -> bool {
if self.is_passing_constraints(interaction) {
self.collected += 1;
if self.sender.send(interaction.as_arc()).is_err() {
return false;
}
}
self.filtered += 1;
self.is_within_limits() && !self.sender.is_closed()
}
fn is_passing_constraints(
&self,
interaction: &mut LazyArc<'_, MessageComponentInteraction>,
) -> bool {
self.options.guild_id.map_or(true, |id| Some(id) == interaction.guild_id.map(|g| g.0))
&& self.options.message_id.map_or(true, |id| interaction.message.id.0 == id)
&& self.options.channel_id.map_or(true, |id| id == interaction.channel_id.as_ref().0)
&& self.options.author_id.map_or(true, |id| id == interaction.user.id.0)
&& self.options.filter.as_ref().map_or(true, |f| f(&interaction.as_arc()))
}
fn is_within_limits(&self) -> bool {
self.options.filter_limit.map_or(true, |limit| self.filtered < limit)
&& self.options.collect_limit.map_or(true, |limit| self.collected < limit)
}
}
#[derive(Clone, Default)]
struct FilterOptions {
filter_limit: Option<u32>,
collect_limit: Option<u32>,
filter: Option<Arc<dyn Fn(&Arc<MessageComponentInteraction>) -> bool + 'static + Send + Sync>>,
channel_id: Option<u64>,
guild_id: Option<u64>,
author_id: Option<u64>,
message_id: Option<u64>,
}
impl fmt::Debug for FilterOptions {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ComponentInteractionFilter")
.field("collect_limit", &self.collect_limit)
.field("filter", &"Option<Arc<dyn Fn(&Arc<Reaction>) -> bool + 'static + Send + Sync>>")
.field("channel_id", &self.channel_id)
.field("guild_id", &self.guild_id)
.field("author_id", &self.author_id)
.finish()
}
}
impl_component_interaction_collector! {
CollectComponentInteraction;
ComponentInteractionCollectorBuilder;
}
#[must_use = "Builders do nothing unless built"]
pub struct ComponentInteractionCollectorBuilder {
filter: Option<FilterOptions>,
shard: Option<ShardMessenger>,
timeout: Option<Pin<Box<Sleep>>>,
}
impl ComponentInteractionCollectorBuilder {
pub fn new(shard_messenger: impl AsRef<ShardMessenger>) -> Self {
Self {
filter: Some(FilterOptions::default()),
shard: Some(shard_messenger.as_ref().clone()),
timeout: None,
}
}
#[allow(clippy::unwrap_used)]
#[must_use]
pub fn build(self) -> ComponentInteractionCollector {
let shard_messenger = self.shard.unwrap();
let (filter, receiver) = ComponentInteractionFilter::new(self.filter.unwrap());
let timeout = self.timeout;
shard_messenger.set_component_interaction_filter(filter);
ComponentInteractionCollector {
receiver: Box::pin(receiver),
timeout,
}
}
}
#[must_use = "Builders do nothing unless awaited"]
pub struct CollectComponentInteraction {
filter: Option<FilterOptions>,
shard: Option<ShardMessenger>,
timeout: Option<Pin<Box<Sleep>>>,
fut: Option<BoxFuture<'static, Option<Arc<MessageComponentInteraction>>>>,
}
impl CollectComponentInteraction {
pub fn new(shard_messenger: impl AsRef<ShardMessenger>) -> Self {
Self {
filter: Some(FilterOptions::default()),
shard: Some(shard_messenger.as_ref().clone()),
timeout: None,
fut: None,
}
}
}
impl Future for CollectComponentInteraction {
type Output = Option<Arc<MessageComponentInteraction>>;
#[allow(clippy::unwrap_used)]
fn poll(mut self: Pin<&mut Self>, ctx: &mut FutContext<'_>) -> Poll<Self::Output> {
if self.fut.is_none() {
let shard_messenger = self.shard.take().unwrap();
let (filter, receiver) = ComponentInteractionFilter::new(self.filter.take().unwrap());
let timeout = self.timeout.take();
self.fut = Some(Box::pin(async move {
shard_messenger.set_component_interaction_filter(filter);
ComponentInteractionCollector {
receiver: Box::pin(receiver),
timeout,
}
.next()
.await
}));
}
self.fut.as_mut().unwrap().as_mut().poll(ctx)
}
}
pub struct ComponentInteractionCollector {
receiver: Pin<Box<Receiver<Arc<MessageComponentInteraction>>>>,
timeout: Option<Pin<Box<Sleep>>>,
}
impl ComponentInteractionCollector {
pub fn stop(mut self) {
self.receiver.close();
}
}
impl Stream for ComponentInteractionCollector {
type Item = Arc<MessageComponentInteraction>;
fn poll_next(mut self: Pin<&mut Self>, ctx: &mut FutContext<'_>) -> Poll<Option<Self::Item>> {
if let Some(ref mut timeout) = self.timeout {
match timeout.as_mut().poll(ctx) {
Poll::Ready(_) => {
return Poll::Ready(None);
},
Poll::Pending => (),
}
}
self.receiver.as_mut().poll_recv(ctx)
}
}
impl Drop for ComponentInteractionCollector {
fn drop(&mut self) {
self.receiver.close();
}
}