WIP: impl more signalproxy objects

1 files changed, 150 insertions, 95 deletions

diff --git a/src/message/signalproxy/objects/ircchannel.rs b/src/message/signalproxy/objects/ircchannel.rs
index b15d789..ee23f07 100644
--- a/src/message/signalproxy/objects/ircchannel.rs
+++ b/src/message/signalproxy/objects/ircchannel.rs
@@ -1,22 +1,119 @@
 use std::collections::HashMap;
+use std::convert::TryFrom;
+use std::convert::TryInto;
 
-use crate::primitive::{StringList, Variant, VariantMap};
+use crate::primitive::{StringList, Variant, VariantList, VariantMap};
 
-#[allow(unused_imports)]
 use crate::message::signalproxy::Network;
 
 #[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq)]
 pub struct IrcChannel {
-    channel_modes_a: HashMap<char, StringList>,
-    channel_modes_b: HashMap<char, String>,
-    channel_modes_c: HashMap<char, String>,
-    channel_modes_d: String,
-    user_modes: HashMap<String, String>,
-    name: String,
-    topic: String,
-    password: String,
-    encrypted: bool,
+    pub channel_modes_a: HashMap<char, StringList>,
+    pub channel_modes_b: HashMap<char, String>,
+    pub channel_modes_c: HashMap<char, String>,
+    pub channel_modes_d: String,
+    // pub channel_modes: HashMap<char, ChannelMode>,
+    pub user_modes: HashMap<String, String>,
+    pub name: String,
+    pub topic: String,
+    pub password: String,
+    pub encrypted: bool,
+}
+
+// #[derive(Debug, Clone, PartialEq)]
+// pub enum ChannelMode {
+//     A(char, StringList),
+//     B(char, String),
+//     C(char, String),
+//     D(char),
+// }
+
+impl Network for Vec<IrcChannel> {
+    type Item = VariantMap;
+
+    fn to_network(&self) -> Self::Item {
+        let mut channelmodes: VariantList = Vec::with_capacity(self.len());
+        let mut usermodes: VariantList = Vec::with_capacity(self.len());
+        let mut name: VariantList = Vec::with_capacity(self.len());
+        let mut topic: VariantList = Vec::with_capacity(self.len());
+        let mut password: VariantList = Vec::with_capacity(self.len());
+        let mut encrypted: VariantList = Vec::with_capacity(self.len());
+
+        let mut map = VariantMap::new();
+
+        self.iter().for_each(|item| {
+            channelmodes.push(Variant::VariantMap({
+                let mut map = VariantMap::new();
+
+                map.insert(
+                    s!("A"),
+                    Variant::VariantMap(
+                        item.channel_modes_a
+                            .iter()
+                            .map(|(k, v)| (k.to_string(), Variant::StringList(v.clone())))
+                            .collect(),
+                    ),
+                );
+                map.insert(
+                    s!("B"),
+                    Variant::VariantMap(
+                        item.channel_modes_b
+                            .iter()
+                            .map(|(k, v)| (k.to_string(), Variant::String(v.clone())))
+                            .collect(),
+                    ),
+                );
+                map.insert(
+                    s!("C"),
+                    Variant::VariantMap(
+                        item.channel_modes_c
+                            .iter()
+                            .map(|(k, v)| (k.to_string(), Variant::String(v.clone())))
+                            .collect(),
+                    ),
+                );
+                map.insert(s!("D"), Variant::String(item.channel_modes_d.clone()));
+
+                map
+            }));
+
+            usermodes.push(Variant::VariantMap(
+                item.user_modes
+                    .iter()
+                    .map(|(k, v)| (k.clone(), Variant::String(v.clone())))
+                    .collect(),
+            ));
+            name.push(Variant::String(item.name.clone()));
+            topic.push(Variant::String(item.topic.clone()));
+            password.push(Variant::String(item.password.clone()));
+            encrypted.push(Variant::bool(item.encrypted));
+        });
+
+        map.insert(
+            String::from("ChanModes"),
+            Variant::VariantList(channelmodes),
+        );
+        map.insert(String::from("UserModes"), Variant::VariantList(usermodes));
+        map.insert(String::from("name"), Variant::VariantList(name));
+        map.insert(String::from("topic"), Variant::VariantList(topic));
+        map.insert(String::from("password"), Variant::VariantList(password));
+        map.insert(String::from("encrypted"), Variant::VariantList(encrypted));
+
+        map
+    }
+
+    fn from_network(input: &mut Self::Item) -> Self {
+        let marker: VariantList =
+            std::convert::TryInto::try_into(input.get("name").unwrap()).unwrap();
+
+        let mut res = Vec::new();
+        for _ in 0..marker.len() {
+            res.push(IrcChannel::from_network(input));
+        }
+
+        return res;
+    }
 }
 
 impl Network for IrcChannel {
@@ -92,90 +189,48 @@ impl Network for IrcChannel {
         res
     }
     fn from_network(input: &mut Self::Item) -> Self {
+        let mut chanmodes: VariantMap = match_variant!(
+            match_variant!(input.get_mut("ChanModes").unwrap(), Variant::VariantList).remove(0),
+            Variant::VariantMap
+        );
+
         Self {
-            channel_modes_a: match_variant!(
-                match_variant!(
-                    match_variant!(input.get("ChanModes").unwrap(), Variant::VariantList)[0],
-                    Variant::VariantMap
-                )
-                .get("B")
-                .unwrap(),
-                Variant::VariantMap
+            channel_modes_a: match_variant!(chanmodes.remove("A").unwrap(), Variant::VariantMap)
+                .into_iter()
+                .map(|(mut k, v)| (k.remove(0), match_variant!(v, Variant::StringList)))
+                .collect(),
+            channel_modes_b: match_variant!(chanmodes.remove("B").unwrap(), Variant::VariantMap)
+                .into_iter()
+                .map(|(mut k, v)| (k.remove(0), match_variant!(v, Variant::String)))
+                .collect(),
+            channel_modes_c: match_variant!(chanmodes.remove("C").unwrap(), Variant::VariantMap)
+                .into_iter()
+                .map(|(mut k, v)| (k.remove(0), match_variant!(v, Variant::String)))
+                .collect(),
+            channel_modes_d: match_variant!(chanmodes.remove("D").unwrap(), Variant::String),
+            user_modes: VariantMap::try_from(
+                match_variant!(input.get_mut("UserModes").unwrap(), Variant::VariantList).remove(0),
             )
-            .iter()
-            .map(|(k, v)| {
-                (
-                    k.chars().nth(0).unwrap(),
-                    match_variant!(v, Variant::StringList),
-                )
-            })
+            .unwrap()
+            .into_iter()
+            .map(|(k, v)| (k, v.try_into().unwrap()))
             .collect(),
-            channel_modes_b: match_variant!(
-                match_variant!(
-                    match_variant!(input.get("ChanModes").unwrap(), Variant::VariantList)[0],
-                    Variant::VariantMap
-                )
-                .get("B")
+            name: match_variant!(input.get_mut("name").unwrap(), Variant::VariantList)
+                .remove(0)
+                .try_into()
                 .unwrap(),
-                Variant::VariantMap
-            )
-            .iter()
-            .map(|(k, v)| {
-                (
-                    k.chars().nth(0).unwrap(),
-                    match_variant!(v, Variant::String),
-                )
-            })
-            .collect(),
-            channel_modes_c: match_variant!(
-                match_variant!(
-                    match_variant!(input.get("ChanModes").unwrap(), Variant::VariantList)[0],
-                    Variant::VariantMap
-                )
-                .get("C")
+            topic: match_variant!(input.get_mut("topic").unwrap(), Variant::VariantList)
+                .remove(0)
+                .try_into()
                 .unwrap(),
-                Variant::VariantMap
-            )
-            .iter()
-            .map(|(k, v)| {
-                (
-                    k.chars().nth(0).unwrap(),
-                    match_variant!(v, Variant::String),
-                )
-            })
-            .collect(),
-            channel_modes_d: match_variant!(
-                match_variant!(
-                    match_variant!(input.get("ChanModes").unwrap(), Variant::VariantList)[0],
-                    Variant::VariantMap
-                )
-                .get("D")
+            password: match_variant!(input.get_mut("password").unwrap(), Variant::VariantList)
+                .remove(0)
+                .try_into()
+                .unwrap(),
+            encrypted: match_variant!(input.get_mut("encrypted").unwrap(), Variant::VariantList)
+                .remove(0)
+                .try_into()
                 .unwrap(),
-                Variant::String
-            ),
-            user_modes: match_variant!(
-                match_variant!(input.get("UserModes").unwrap(), Variant::VariantList)[0],
-                Variant::VariantMap
-            )
-            .iter()
-            .map(|(k, v)| (k.clone(), match_variant!(v, Variant::String)))
-            .collect(),
-            name: match_variant!(
-                match_variant!(input.get("name").unwrap(), Variant::VariantList)[0],
-                Variant::String
-            ),
-            topic: match_variant!(
-                match_variant!(input.get("topic").unwrap(), Variant::VariantList)[0],
-                Variant::String
-            ),
-            password: match_variant!(
-                match_variant!(input.get("password").unwrap(), Variant::VariantList)[0],
-                Variant::String
-            ),
-            encrypted: match_variant!(
-                match_variant!(input.get("encrypted").unwrap(), Variant::VariantList)[0],
-                Variant::bool
-            ),
         }
     }
 }
@@ -185,7 +240,7 @@ mod tests {
     use super::*;
 
     fn get_network() -> VariantMap {
-        VariantMap::from(map! {
+        map! {
             s!("encrypted") => Variant::VariantList(
                 vec![
                     Variant::bool(
@@ -233,9 +288,9 @@ mod tests {
                                     ),
                                 },
                             ),
-                            s!("A") => Variant::VariantMap(map!
-                                {},
-                            ),
+                            s!("A") => Variant::VariantMap(map! {
+                                s!("b") => Variant::StringList(vec![s!("*!*@test"), s!("*!*@test2")]),
+                            }),
                         },
                     ),
                 ],
@@ -261,11 +316,11 @@ mod tests {
                     ),
                 ],
             )
-        })
+        }
     }
     fn get_runtime() -> IrcChannel {
         IrcChannel {
-            channel_modes_a: map! {},
+            channel_modes_a: map! { 'b' => vec![s!("*!*@test"), s!("*!*@test2")] },
             channel_modes_b: map! {},
             channel_modes_c: map! { 'j' => s!("5:1"), 'x' => s!("10:5"), 'f' => s!("30:5"), 'F' => s!("5:60") },
             channel_modes_d: s!("tCnT"),