From 1b4ece22a5dcecce4359f06bacf0f0cbc7d82731 Mon Sep 17 00:00:00 2001
From: Isabelle L <me@izzabelle.dev>
Date: Sun, 10 May 2020 01:57:30 -0500
Subject: [PATCH] some stuff idfk

---
 src/lib.rs    | 19 +++++++++++++++----
 src/packet.rs | 48 +++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 60 insertions(+), 7 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 6574d73..4ec7f70 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,11 +2,17 @@ use async_std::net::TcpListener;
 use async_std::net::TcpStream;
 use async_std::prelude::*;
 
+mod packet;
+
 pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 
 pub async fn server(port: u16) -> Result<()> {
     let listener = TcpListener::bind(format!("127.0.0.1:{}", &port)).await?;
-    println!("online as server at: {}:{}", listener.local_addr()?.ip(), port);
+    println!(
+        "online as server at: {}:{}",
+        listener.local_addr()?.ip(),
+        port
+    );
     let mut incoming = listener.incoming();
 
     while let Some(stream) = incoming.next().await {
@@ -21,9 +27,14 @@ pub async fn server(port: u16) -> Result<()> {
 
 pub async fn client(port: u16) -> Result<()> {
     let mut stream = TcpStream::connect(format!("127.0.0.1:{}", &port)).await?;
-    println!("connection established to: {}:{}", stream.peer_addr()?.ip(), port);
-    let mut buf = vec![0u8; 1024];
+    println!(
+        "connection established to: {}:{}",
+        stream.peer_addr()?.ip(),
+        port
+    );
+
+    /*let mut buf = vec![0u8; 1024];
     stream.read(&mut buf).await?;
-    println!("{}", String::from_utf8_lossy(&mut buf));
+    println!("{}", String::from_utf8_lossy(&mut buf));*/
     Ok(())
 }
diff --git a/src/packet.rs b/src/packet.rs
index 17dd83a..56ac7aa 100644
--- a/src/packet.rs
+++ b/src/packet.rs
@@ -1,10 +1,34 @@
+// namespacing
 use chrono::prelude::*;
+use serde::Serialize;
 
-struct NetworkPacket(String);
+/// structured [packet type byte][four bytes of packet length][contents of packet]
+struct NetworkPacket(Vec<u8>);
+
+impl std::convert::TryInto<NetworkPacket> for Packet {
+    type Error = Box<dyn std::error::Error>;
+
+    fn try_into(self) -> crate::Result<NetworkPacket> {
+        let mut contents: Vec<u8> = Vec::new();
+
+        // packet type byte
+        contents.push(self.packet_type as u8);
+        // create room for the packet length
+        (1..5).for_each(|_| contents.push(0x00));
+        // write the rest of the contents
+        self.packet_contents
+            .iter()
+            .for_each(|byte| contents.push(*byte));
+        // write the packet len bytes
+        let packet_length = ((self.packet_contents.len() + 5) as u32).to_le_bytes();
+        (1..5).for_each(|i| contents[i] = packet_length[i - 1]);
+
+        Ok(NetworkPacket(contents))
+    }
+}
 
 struct Packet {
     packet_type: PacketType,
-    packet_length: u64,
     packet_contents: Vec<u8>,
 }
 
@@ -13,6 +37,7 @@ enum PacketType {
     NewMessage = 0,
 }
 
+#[derive(Serialize)]
 struct NewMessage {
     user: String,
     contents: String,
@@ -22,6 +47,23 @@ struct NewMessage {
 impl NewMessage {
     pub fn new(user: String, contents: String) -> Self {
         let timestamp = Utc::now().timestamp();
-        Self { user, contents, timestamp }
+        Self {
+            user,
+            contents,
+            timestamp,
+        }
+    }
+}
+
+impl std::convert::TryInto<Packet> for NewMessage {
+    type Error = Box<dyn std::error::Error>;
+
+    fn try_into(self) -> crate::Result<Packet> {
+        let packet_contents: Vec<u8> = serde_json::to_string(&self)?.into_bytes();
+        let packet_type = PacketType::NewMessage;
+        Ok(Packet {
+            packet_type,
+            packet_contents,
+        })
     }
 }