1 files changed, 71 insertions, 12 deletions

diff --git a/game_server/src/backend_connection.rs b/game_server/src/backend_connection.rs
index 9307c4a..a751b30 100644
--- a/game_server/src/backend_connection.rs
+++ b/game_server/src/backend_connection.rs
@@ -1,31 +1,90 @@
 use reqwest::{Response, Client, Url, UrlError, Error as ReqError};
+use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc;
+use crate::server::{UserId, Token};
+use crate::group::GroupId;
 
 pub struct BackendConnection {
     host: String,
-    client: Client,
-    last_response: Option<Result<Response, ReqError>>
+    req_sender: Sender<RequestData>,
+    res_rec: Receiver<ResponseResult>,
+    max_uid: u32,
+}
+
+#[derive(Debug)]
+pub enum BackendError {
+    UrlError(UrlError),
+    RequestError(ReqError),
+    InvalidTokenFormat,
+    InvalidToken,
+    BadResponse(Response),
+}
+
+pub type TokenValidity = Result<TokenResponse, BackendError>;
+pub type RequestData = Url;
+pub type ResponseResult = Result<Response, ReqError>;
+
+pub struct TokenResponse {
+    pub group_id: GroupId,
+    pub group_type: String,
+    pub group_name: String,
+    pub user_id: UserId,
 }
 
 impl BackendConnection {
+    fn run_background(req_rec: Receiver<RequestData>, res_sender: Sender<ResponseResult>) {
+        let client = Client::new();
+        loop {
+            let request_data = req_rec.recv().unwrap();
+            let location = request_data;
+            let request = client.get(location);
+            let response = request.send();
+            res_sender.send(response).unwrap();
+        }
+    }
+
     pub fn new(host: &str) -> Self {
+        let (req_sender, req_rec): (Sender<RequestData>, Receiver<RequestData>)
+                                    = mpsc::channel();
+        let (res_sender, res_rec): (Sender<ResponseResult>, Receiver<ResponseResult>)
+                                    = mpsc::channel();
+        std::thread::spawn(move || Self::run_background(req_rec, res_sender));
         BackendConnection {
             host: host.to_string(),
-            client: Client::new(),
-            last_response: None
+            req_sender,
+            res_rec,
+            max_uid: 420,
         }
     }
 
-    pub fn request(&mut self, location: &str) -> Result<(), UrlError> {
-        Ok(self.last_response =
-                Some(self.client.get(Url::parse(&format!("{}{}", self.host, location))?)
-                           .send()))
+    pub fn request(&self, location: &str) -> Result<(), UrlError> {
+        Ok(self.req_sender.send(Url::parse(&format!("{}{}", self.host, location))?).unwrap())
     }
 
-    pub fn get_response(&self) -> &Option<Result<Response, ReqError>> {
-        &self.last_response
+    pub fn get_response(&self) -> ResponseResult {
+        self.res_rec.recv().unwrap()
     }
     
-    pub fn host_name<'a>(&'a self) -> &'a str {
-        &self.host
+    pub fn validate_token(&mut self, token: &Token) -> TokenValidity {
+        let location = format!("/api/lobby/tokens/{}", token);
+        self.request(&location).map_err(|err| BackendError::UrlError(err))?;
+        let response = self.get_response().map_err(|err| BackendError::RequestError(err))?;
+        if response.status().is_success() {
+            // zu Testzwecken werden noch keine JSON-Daten deserialisiert
+            // Dennis Server gibt ja noch nix zurück
+            self.max_uid += 1;
+            Ok(TokenResponse {
+                group_id: 12,
+                group_type: "scribble".to_string(),
+                group_name: "Scribble".to_string(),
+                user_id: self.max_uid - 1,
+            })
+        } else if response.status() == reqwest::StatusCode::NOT_FOUND {
+            Err(BackendError::InvalidToken)
+        } else if response.status().is_client_error() {
+            Err(BackendError::InvalidTokenFormat)
+        } else {
+            Err(BackendError::BadResponse(response))
+        }
     }
 }