From 436975e3c506a93bab8490f9c326b470991d3ef2 Mon Sep 17 00:00:00 2001
From: michael-bailey <mickyb18a@gmail.com>
Date: Thu, 18 Mar 2021 16:05:27 +0000
Subject: [PATCH] Moved TcpListender form Server To NetworkManage.

---
 src/lib/server/mod.rs                 | 34 +-------------
 src/lib/server/network_manager/mod.rs | 66 ++++++++++++++++++++++++---
 2 files changed, 60 insertions(+), 40 deletions(-)

diff --git a/src/lib/server/mod.rs b/src/lib/server/mod.rs
index a6950c5..f7209fe 100644
--- a/src/lib/server/mod.rs
+++ b/src/lib/server/mod.rs
@@ -27,7 +27,6 @@ pub enum ServerMessages {
 }
 
 pub struct Server {
-	server_socket: TcpListener,
 	client_manager: Arc<ClientManager>,
   network_manager: Arc<NetworkManager>,
 
@@ -37,11 +36,9 @@ pub struct Server {
 
 impl Server {
 	pub fn new() -> Arc<Server> {
-		let listener = TcpListener::bind("0.0.0.0:5600").expect("Could not bind to address");
 		let (sender, receiver) = unbounded();
 
 		Arc::new(Server {
-			server_socket: listener,
 			client_manager: ClientManager::new(sender.clone()),
 
       network_manager: NetworkManager::new("5600".to_string(), sender.clone()),
@@ -59,36 +56,7 @@ impl Server {
 impl ICooperative for Server{
 	fn tick(&self) {
 
-    let mut buffer = vec![0; 64];
-
-    // handle new connections 
-    for connection in self.server_socket.incoming() {
-      match connection {
-        Ok(mut stream) => {
-          stream.write_all(Commands::Request(None).to_string().as_bytes()).expect("error writing socket");
-          stream.read_to_end(&mut buffer).expect("error reading sokcet");
-          
-          println!("buffer: {:?}", &buffer);
-
-          let command = Commands::from(&mut buffer);
-
-          match command {
-            Commands::Info(None) => {
-              let server_config = vec![
-                ("name".to_string(), "Test server".to_string())
-              ];
-              let map: HashMap<String, String> = server_config.into_iter().collect();
-              stream.write_all(Commands::Success(Some(map)).to_string().as_bytes())
-                .expect("error sending response");
-            }
-            Commands::Connect(Some(map)) => println!("connect command: {:?}", &map),
-
-            _ => {let _ = stream.write("not implemented!".as_bytes());}
-          }
-        },
-        _ => println!("!connection error occured!"),
-      }
-    }
+		self.network_manager.tick();
 
     // handle new messages loop
     for message in self.receiver.iter() {
diff --git a/src/lib/server/network_manager/mod.rs b/src/lib/server/network_manager/mod.rs
index a5aa7ec..4db6c2c 100644
--- a/src/lib/server/network_manager/mod.rs
+++ b/src/lib/server/network_manager/mod.rs
@@ -1,26 +1,41 @@
 
-use std::sync::Arc;
-use crate::lib::server::ServerMessages;
 use std::net::TcpListener;
+use std::sync::Arc;
+use std::io::BufReader;
+use std::io::BufWriter;
+use std::io::Write;
+use std::io::BufRead;
 
 use serde::{Deserialize, Serialize};
 use crossbeam_channel::Sender;
 
+use crate::lib::server::ServerMessages;
 use crate::lib::Foundation::ICooperative;
 
+
+/// # NetworkSockIn
+/// these messages can be sent by a client on connecting
 #[derive(Serialize, Deserialize)]
-enum NetworkSocketMesssages {
-  Info {id: String},
-  Connect {id: String, uuid: String, username: String, address: String},
+enum NetworkSockIn {
+  Info,
+  Connect {uuid: String, username: String, address: String},
 }
 
+/// # NetworkSockOut
+/// these messages are sent by the network manager on connecting and requesting
+#[derive(Serialize, Deserialize)]
+enum NetworkSockOut<'a> {
+	Request,
+	GotInfo {server_name: &'a str, server_owner: &'a str}
+}
+
+// these are control signals from the server.
 pub enum NetworkMessages {
 
 }
 
 pub struct NetworkManager {
   listener: TcpListener,
-
   server_channel: Sender<ServerMessages>,
 }
 
@@ -41,6 +56,43 @@ impl NetworkManager {
 
 impl ICooperative for NetworkManager {
   fn tick(&self) {
-    println!("network manager tick")
+    // get all new connections
+		// handle each request
+		for connection in self.listener.incoming() {
+			if let Ok(stream) = connection {
+
+				// create buffered writers
+				let mut reader = BufReader::new(stream.try_clone().unwrap());
+				let mut writer = BufWriter::new(stream.try_clone().unwrap());
+
+				let mut buffer = String::new();
+
+				// request is always sent on new connection
+				writer.write_all(serde_json::to_string(&NetworkSockOut::Request).unwrap().as_bytes()).unwrap();
+				writer.write_all(b"\n").unwrap();
+				writer.flush().unwrap();
+
+				// read the new request into a buffer
+				reader.read_line(&mut buffer).unwrap();
+
+				// turn into enum for pattern matching
+				let request = serde_json::from_str::<NetworkSockIn>(&buffer).unwrap();
+
+				// perform action based on the enum
+				match request {
+					NetworkSockIn::Info => {
+						writer.write_all(
+							serde_json::to_string(
+								&NetworkSockOut::GotInfo {server_name: "oof", server_owner: "michael"}
+							).unwrap().as_bytes()
+						).unwrap();
+						writer.flush().unwrap();
+					}
+					NetworkSockIn::Connect { uuid, username, address } => {
+						println!("Connection requested")
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file