1 files changed, 74 insertions, 0 deletions
diff --git a/src/system/types.rs b/src/system/types.rs
index aaef165..2acf156 100644
--- a/src/system/types.rs
+++ b/src/system/types.rs
@@ -6,6 +6,7 @@ use twilight_model::channel::Message;
 use twilight_model::id::{marker::{ChannelMarker, UserMarker}, Id};
 use std::{collections::HashMap, sync::Arc};
 use tokio::sync::Mutex;
+use futures::future::join_all;
 
 #[derive(Clone)]
 pub struct Member {
@@ -68,4 +69,77 @@ impl System {
     pub async fn get_most_recent_message(&self, channel: Id<ChannelMarker>) -> Option<(Message, Member)> {
         self.message_cache.lock().await.get(&channel).map(|(member, message)| (message.clone(), member.clone()))
     }
+
+    // Returns either the most recent message or replied message, with bool to indicate
+    // if it was the most recent message (and the cache should be updated if that's modified)
+    pub async fn resolve_message_target(&self, message: &Message) -> Option<(Message, bool)> {
+        let most_recent_message = self.get_most_recent_message(message.channel_id).await;
+
+        if let Some(result) = async {
+            match message.kind {
+                twilight_model::channel::message::MessageType::Regular => Some((most_recent_message?.0, true)),
+                twilight_model::channel::message::MessageType::Reply => Some((
+                    message.referenced_message.as_ref()?.as_ref().clone(),
+                    message.referenced_message.as_ref()?.id == most_recent_message?.0.id
+                )),
+                _ => return None,
+            }
+        }.await {
+            return Some(result)
+        } else {
+            let member_ids = join_all(self.members.iter().map(|member| async {
+                member.user_id.lock().await.clone()
+            })).await.iter().filter_map(|opt| *opt).collect::<Vec<_>>();
+
+            for member in &self.members {
+                let client = member.client.lock().await; 
+
+                let lookup: Result<Vec<Message>, LookupError> = async {
+                    Ok(client
+                        .channel_messages(message.channel_id)
+                        .limit(10)?
+                        .await?
+                        .model()
+                        .await?
+                    )
+                }.await;
+
+                if let Ok(recent_messages) = lookup {
+                    let recent_message = recent_messages.into_iter().find(
+                        |message| member_ids.contains(&message.author.id)
+                    );
+
+                    if let Some(most_recent_message) = recent_message {
+                        return Some((most_recent_message, true))
+                    } else {
+                        // Successful lookup, but no recent messages, there's no point
+                        // checking with the other members
+                        return None
+                    }
+                }
+            }
+
+            None
+        }
+    }
+}
+
+struct LookupError;
+
+impl From<twilight_validate::request::ValidationError> for LookupError {
+    fn from(_value: twilight_validate::request::ValidationError) -> Self {
+        Self
+    }
+}
+
+impl From<twilight_http::Error> for LookupError {
+    fn from(_value: twilight_http::Error) -> Self {
+        Self
+    }
+}
+
+impl From<twilight_http::response::DeserializeBodyError> for LookupError {
+    fn from(_value: twilight_http::response::DeserializeBodyError) -> Self {
+        Self
+    }
 }