From 6209393cd07e2b31bfe13bc531402f691dc576f1 Mon Sep 17 00:00:00 2001
From: Sijmen <me@vijf.life>
Date: Fri, 17 Nov 2023 09:04:48 +0100
Subject: [PATCH] Implement /join, /part and /query

---
 src/main.rs | 108 +++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 86 insertions(+), 22 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 38f7ac6..e659030 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -58,6 +58,81 @@ struct Cri {
     input_value: String,
 }
 
+impl Cri {
+    fn send_message(&mut self, input_value: &str) {
+        if let Some(active_channel) = &self.message_log.active_channel {
+            let command = IrcCommand::PRIVMSG(active_channel.to_string(), input_value.to_string());
+            let message: irc::proto::Message = command.into();
+
+            self.message_log
+                .get_mut(self.message_log.active_channel.clone())
+                .messages
+                .push(IrcMessage::Privmsg {
+                    nickname: String::from("cri"),
+                    message: input_value.to_string(),
+                });
+
+            self.input_tx.borrow().send(message.clone()).unwrap();
+        }
+    }
+
+    fn send_command(&mut self, command: &str) {
+        let mut tokens = command.split_whitespace();
+
+        let command = tokens.next().unwrap();
+        match command {
+            "/join" => {
+                let channel = tokens.next().map(str::to_string).or_else(|| self.message_log.active_channel.clone());
+                if channel.is_none() {
+                    // TODO error message
+                    return;
+                }
+
+                let channel = channel.unwrap();
+                if !channel.starts_with('#') {
+                    // TODO error message
+                    return;
+                }
+
+                self
+                .input_tx
+                .borrow()
+                .send(IrcCommand::JOIN(channel, tokens.next().map(str::to_string), None).into())
+                .unwrap()
+            },
+            "/part" => {
+                let channel = tokens.next().map(str::to_string).or_else(|| self.message_log.active_channel.clone());
+                if channel.is_none() {
+                    // TODO error message
+                    return;
+                }
+
+                let channel = channel.unwrap();
+                if !channel.starts_with('#') {
+                    // TODO error message
+                    return;
+                }
+
+                self
+                .input_tx
+                .borrow()
+                .send(
+                    IrcCommand::PART(
+                        channel,
+                        tokens.next().map(str::to_string),
+                    )
+                    .into(),
+                )
+                .unwrap()
+            }
+            "/query" => self
+                .message_log
+                .set_active(Some(tokens.next().unwrap().to_string())),
+            _ => todo!(),
+        }
+    }
+}
+
 impl Application for Cri {
     type Executor = executor::Default;
     type Message = UiMessage;
@@ -81,33 +156,31 @@ impl Application for Cri {
     }
 
     fn update(&mut self, message: Self::Message) -> iced::Command<Self::Message> {
-        use irc::proto::Command;
-
         match message {
             UiMessage::IrcMessageReceived(message) => {
                 // TODO use actual nickname
                 let source_nickname = message.source_nickname().unwrap_or("cri").to_string();
 
                 match &message.command {
-                    Command::JOIN(chanlist, _, _) => {
+                    IrcCommand::JOIN(chanlist, _, _) => {
                         self.message_log.on_join(chanlist, &source_nickname);
                     }
 
-                    Command::PART(chanlist, comment) => {
+                    IrcCommand::PART(chanlist, comment) => {
                         self.message_log
                             .on_part(chanlist, &source_nickname, comment.as_deref());
                     }
 
-                    Command::NICK(new) => {
+                    IrcCommand::NICK(new) => {
                         self.message_log.on_nick(&source_nickname, new);
                     }
 
-                    Command::QUIT(comment) => {
+                    IrcCommand::QUIT(comment) => {
                         self.message_log
                             .on_quit(&source_nickname, comment.as_deref());
                     }
 
-                    Command::PRIVMSG(msgtarget, content) => {
+                    IrcCommand::PRIVMSG(msgtarget, content) => {
                         let channel = message.response_target().unwrap_or(msgtarget).to_string();
                         self.message_log
                             .on_privmsg(&channel, &source_nickname, content);
@@ -118,21 +191,12 @@ impl Application for Cri {
             }
             UiMessage::InputChanged(text) => self.input_value = text,
             UiMessage::InputSubmitted => {
-                if let Some(active_channel) = &self.message_log.active_channel {
-                    let command = irc::proto::Command::PRIVMSG(
-                        active_channel.to_string(),
-                        self.input_value.clone(),
-                    );
-                    let message: irc::proto::Message = command.into();
-
-                    self.message_log
-                        .get_mut(self.message_log.active_channel.clone())
-                        .messages
-                        .push(IrcMessage::Privmsg {
-                            nickname: String::from("cri"),
-                            message: self.input_value.clone(),
-                        });
-                    self.input_tx.borrow().send(message.clone()).unwrap();
+                if self.input_value.starts_with("//") {
+                    self.send_message(&self.input_value.clone()[1..])
+                } else if self.input_value.starts_with('/') {
+                    self.send_command(&self.input_value.clone())
+                } else {
+                    self.send_message(&self.input_value.clone());
                 }
 
                 self.input_value.clear();