1 files changed, 52 insertions, 32 deletions

diff --git a/src/message/handshake/sessioninit.rs b/src/message/handshake/sessioninit.rs
index eca4c10..d1b4b90 100644
--- a/src/message/handshake/sessioninit.rs
+++ b/src/message/handshake/sessioninit.rs
@@ -1,61 +1,81 @@
-use crate::error::ProtocolError;
-use crate::primitive::{Variant, VariantList, VariantMap};
-use crate::{HandshakeDeserialize, HandshakeSerialize};
+use crate::message::objects::Identity;
+use crate::primitive::{BufferInfo, Variant, VariantMap};
+use crate::HandshakeSerialize;
 
 use failure::Error;
 
 /// SessionInit is received along with ClientLoginAck to initialize that user Session
 // TODO Replace with proper types
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct SessionInit {
     /// List of all configured identities
-    identities: VariantList,
+    pub identities: Vec<Identity>,
     /// List of all existing buffers
-    buffers: VariantList,
+    pub buffers: Vec<BufferInfo>,
     /// Ids of all networks
-    network_ids: VariantList,
+    pub network_ids: Vec<i32>,
+}
+
+impl From<VariantMap> for SessionInit {
+    fn from(input: VariantMap) -> Self {
+        let state = match_variant!(input.get("SessionState").unwrap(), Variant::VariantMap);
+        SessionInit {
+            identities: match_variant!(state.get("Identities").unwrap(), Variant::VariantList)
+                .iter()
+                .map(|ident| Identity::from(match_variant!(ident, Variant::VariantMap)))
+                .collect(),
+            buffers: match_variant!(state.get("BufferInfos").unwrap(), Variant::VariantList)
+                .iter()
+                .map(|buffer| match buffer {
+                    Variant::BufferInfo(buffer) => buffer.clone(),
+                    _ => unimplemented!(),
+                })
+                .collect(),
+            network_ids: match_variant!(state.get("NetworkIds").unwrap(), Variant::VariantList)
+                .iter()
+                .map(|network| match network {
+                    Variant::i32(network) => network.clone(),
+                    _ => unimplemented!(),
+                })
+                .collect(),
+        }
+    }
 }
 
 impl HandshakeSerialize for SessionInit {
     fn serialize(&self) -> Result<Vec<u8>, Error> {
-        let mut values: VariantMap = VariantMap::with_capacity(1);
+        let mut values: VariantMap = VariantMap::with_capacity(4);
         values.insert(
             "MsgType".to_string(),
             Variant::String("SessionInit".to_string()),
         );
         values.insert(
             "Identities".to_string(),
-            Variant::VariantList(self.identities.clone()),
+            Variant::VariantList(
+                self.identities
+                    .iter()
+                    .map(|ident| Variant::VariantMap(ident.clone().into()))
+                    .collect(),
+            ),
         );
         values.insert(
             "BufferInfos".to_string(),
-            Variant::VariantList(self.buffers.clone()),
+            Variant::VariantList(
+                self.buffers
+                    .iter()
+                    .map(|buffer| Variant::BufferInfo(buffer.clone()))
+                    .collect(),
+            ),
         );
         values.insert(
             "NetworkIds".to_string(),
-            Variant::VariantList(self.network_ids.clone()),
+            Variant::VariantList(
+                self.network_ids
+                    .iter()
+                    .map(|id| Variant::i32(id.clone()))
+                    .collect(),
+            ),
         );
         return HandshakeSerialize::serialize(&values);
     }
 }
-
-impl HandshakeDeserialize for SessionInit {
-    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
-        let (len, values): (usize, VariantMap) = HandshakeDeserialize::parse(b)?;
-
-        let msgtype = match_variant!(&values["MsgType"], Variant::StringUTF8);
-
-        if msgtype == "ClientLogin" {
-            return Ok((
-                len,
-                Self {
-                    identities: match_variant!(values["Identities"], Variant::VariantList),
-                    buffers: match_variant!(values["BufferInfos"], Variant::VariantList),
-                    network_ids: match_variant!(values["NetworkIds"], Variant::VariantList),
-                },
-            ));
-        } else {
-            bail!(ProtocolError::WrongMsgType);
-        }
-    }
-}