From 93ee23c831cdcf8875605cdcd3e042743f2c5266 Mon Sep 17 00:00:00 2001
From: Adrian Malacoda <adrian.malacoda@monarch-pass.net>
Date: Thu, 22 Feb 2018 23:43:46 -0600
Subject: [PATCH] give the discord module the ability to recieve events and
 transmit messages

---
 src/modules/discord.rs | 113 ++++++++++++++++++++++++-----------------
 1 file changed, 67 insertions(+), 46 deletions(-)

diff --git a/src/modules/discord.rs b/src/modules/discord.rs
index 1a9283d..68533bc 100644
--- a/src/modules/discord.rs
+++ b/src/modules/discord.rs
@@ -14,6 +14,8 @@ use transformable_channels::mpsc::ExtSender;
 use std::fmt;
 use std::fmt::{Debug, Formatter};
 
+use crossbeam;
+
 use {MessageSender, Message, User, Channel};
 
 pub struct DiscordModule {
@@ -96,62 +98,81 @@ fn channel_from_public_channel (discord: Arc<Discord>, channel: discord::model::
 }
 
 impl EventLoop for DiscordModule {
-    fn run (&self, sender: Box<ExtSender<event::Event>>, _: Receiver<Arc<event::Envelope>>) {
+    fn run (&self, sender: Box<ExtSender<event::Event>>, receiver: Receiver<Arc<event::Envelope>>) {
         let discord = Arc::new(Discord::from_bot_token(&self.token[..]).expect("Discord module: Login failed"));
         let (mut connection, _) = discord.connect().expect("Discord module: Connection failed");
 
         info!("Playing {}", self.playing);
         connection.set_game_name(self.playing.clone());
 
-        loop {
-            let event = connection.recv_event();
-            debug!("Received event: {:?}", event);
-
-            match event {
-                Ok(Event::ServerCreate(server)) => {
-                    match server {
-                        PossibleServer::Online(server) => {
-                            info!("Joined server: {}", server.name);
-                            for channel in server.channels {
-                                info!(" - Joined channel: {}", channel.name);
-
-                                match sender.send(event::Event::SelfJoin {
-                                    channel: channel_from_public_channel(discord.clone(), channel)
-                                }) {
-                                    Err(err) => error!("Error sending selfjoin event: {:?}", err),
-                                    Ok(_) => {}
+        crossbeam::scope(|scope| {
+            let discord_sender = discord.clone();
+            scope.spawn(move || {
+                loop {
+                    if let Ok(envelope) = receiver.recv() {
+                        if let event::Event::Message { ref message } = envelope.event {
+                            if let Some(ref channel) = message.channel {
+                                if let Ok(channel_id) = channel.name.parse::<u64>() {
+                                    discord_sender.send_message(discord::model::ChannelId(channel_id), &message.content, "", false);
                                 }
                             }
-                        },
-                        _ => {}
-                    }
-                },
-                Ok(Event::MessageCreate(message)) => {
-                    let author = User {
-                        name: message.author.name.clone(),
-                        sender: Box::new(DiscordMessageSender {
-                            discord: discord.clone(),
-                            channel_id: message.channel_id
-                        })
-                    };
-
-                    let message = Message {
-                        author: author,
-                        content: message.content,
-                        channel: discord.get_channel(message.channel_id).ok().and_then(|channel| make_channel_object(discord.clone(), channel))
-                    };
-
-                    if let Err(err) = sender.send(event::Event::Message { message: message }) {
-                        error!("Error sending message event: {:?}", err)
+                        }
+                    } else {
+                        break;
                     }
                 }
-    			Ok(_) => {}
-    			Err(discord::Error::Closed(code, body)) => {
-	                error!("Gateway closed on us with code {:?}: {}", code, body);
-    				break
-    			}
-    			Err(err) => error!("Received error: {:?}", err)
+            });
+
+            loop {
+                let event = connection.recv_event();
+                debug!("Received event: {:?}", event);
+
+                match event {
+                    Ok(Event::ServerCreate(server)) => {
+                        match server {
+                            PossibleServer::Online(server) => {
+                                info!("Joined server: {}", server.name);
+                                for channel in server.channels {
+                                    info!(" - Joined channel: {}", channel.name);
+
+                                    match sender.send(event::Event::SelfJoin {
+                                        channel: channel_from_public_channel(discord.clone(), channel)
+                                    }) {
+                                        Err(err) => error!("Error sending selfjoin event: {:?}", err),
+                                        Ok(_) => {}
+                                    }
+                                }
+                            },
+                            _ => {}
+                        }
+                    },
+                    Ok(Event::MessageCreate(message)) => {
+                        let author = User {
+                            name: message.author.name.clone(),
+                            sender: Box::new(DiscordMessageSender {
+                                discord: discord.clone(),
+                                channel_id: message.channel_id
+                            })
+                        };
+
+                        let message = Message {
+                            author: author,
+                            content: message.content,
+                            channel: discord.get_channel(message.channel_id).ok().and_then(|channel| make_channel_object(discord.clone(), channel))
+                        };
+
+                        if let Err(err) = sender.send(event::Event::Message { message: message }) {
+                            error!("Error sending message event: {:?}", err)
+                        }
+                    }
+        			Ok(_) => {}
+        			Err(discord::Error::Closed(code, body)) => {
+    	                error!("Gateway closed on us with code {:?}: {}", code, body);
+        				break
+        			}
+        			Err(err) => error!("Received error: {:?}", err)
+                }
             }
-        }
+        });
     }
 }