chore: General cleanup

- Changed some info!() statements to debug!() and warn!()
- Removed most Turbofish syntax cases
- Removed InvalidCodeError and replaced it with InvalidResponse

Signed-off-by: quexeky <git@quexeky.dev>

src-tauri/src/games/downloads/download_agent.rs

@@ -15,6 +15,7 @@ use crate::DB;
 use log::{debug, error, info};
 use rayon::ThreadPoolBuilder;
 use slice_deque::SliceDeque;
+use std::collections::HashMap;
 use std::fs::{create_dir_all, File};
 use std::path::Path;
 use std::sync::mpsc::Sender;
@@ -157,7 +158,7 @@ impl GameDownloadAgent {
             ));
         }
 
-        let manifest_download = response.json::<DropManifest>().unwrap();
+        let manifest_download: DropManifest = response.json().unwrap();
 
         if let Ok(mut manifest) = self.manifest.lock() {
             *manifest = Some(manifest_download);

src-tauri/src/games/downloads/download_logic.rs

@@ -134,9 +134,10 @@ pub fn download_game_chunk(
         .map_err(|e| ApplicationDownloadError::Communication(e.into()))?;
 
     if response.status() != 200 {
-        warn!("{}", response.text().unwrap());
+        let err = response.json().unwrap();
+        warn!("{:?}", err);
         return Err(ApplicationDownloadError::Communication(
-            RemoteAccessError::InvalidCodeError(400),
+            RemoteAccessError::InvalidResponse(err),
         ));
     }
 
@@ -150,7 +151,7 @@ pub fn download_game_chunk(
 
     let content_length = response.content_length();
     if content_length.is_none() {
-        error!("Recieved 0 length content from server");
+        warn!("Recieved 0 length content from server");
         return Err(ApplicationDownloadError::Communication(
             RemoteAccessError::InvalidResponse(response.json().unwrap()),
         ));

src-tauri/src/games/downloads/stored_manifest.rs

@@ -5,7 +5,7 @@ use std::{
     sync::Mutex,
 };
 
-use log::error;
+use log::{error, warn};
 use serde::{Deserialize, Serialize};
 use serde_binary::binary_stream::Endian;
 
@@ -46,7 +46,7 @@ impl StoredManifest {
         match serde_binary::from_vec::<StoredManifest>(s, Endian::Little) {
             Ok(manifest) => manifest,
             Err(e) => {
-                error!("{}", e);
+                warn!("{}", e);
                 StoredManifest::new(game_id, game_version, base_path)
             }
         }

src-tauri/src/games/library.rs

@@ -2,7 +2,7 @@ use std::fs::remove_dir_all;
 use std::sync::Mutex;
 use std::thread::spawn;
 
-use log::{error, info};
+use log::{error, info, warn};
 use serde::{Deserialize, Serialize};
 use tauri::Emitter;
 use tauri::{AppHandle, Manager};
@@ -91,10 +91,12 @@ fn fetch_library_logic(app: AppHandle) -> Result<Vec<Game>, RemoteAccessError> {
         .send()?;
 
     if response.status() != 200 {
-        return Err(response.status().as_u16().into());
+        let err = response.json().unwrap();
+        warn!("{:?}", err);
+        return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    let games: Vec<Game> = response.json::<Vec<Game>>()?;
+    let games: Vec<Game> = response.json()?;
 
     let state = app.state::<Mutex<AppState>>();
     let mut handle = state.lock().unwrap();
@@ -155,12 +157,12 @@ fn fetch_game_logic(
         return Err(RemoteAccessError::GameNotFound);
     }
     if response.status() != 200 {
-        return Err(RemoteAccessError::InvalidCodeError(
-            response.status().into(),
-        ));
+        let err = response.json().unwrap();
+        warn!("{:?}", err);
+        return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    let game = response.json::<Game>()?;
+    let game: Game = response.json()?;
     state_handle.games.insert(id.clone(), game.clone());
 
     let mut db_handle = DB.borrow_data_mut().unwrap();
@@ -217,19 +219,19 @@ fn fetch_game_verion_options_logic(
         .send()?;
 
     if response.status() != 200 {
-        return Err(RemoteAccessError::InvalidCodeError(
-            response.status().into(),
-        ));
+        let err = response.json().unwrap();
+        warn!("{:?}", err);
+        return Err(RemoteAccessError::InvalidResponse(err));
     }
 
-    let data = response.json::<Vec<GameVersionOption>>()?;
+    let data: Vec<GameVersionOption> = response.json()?;
 
     let state_lock = state.lock().unwrap();
     let process_manager_lock = state_lock.process_manager.lock().unwrap();
-    let data = data
+    let data: Vec<GameVersionOption> = data
         .into_iter()
         .filter(|v| process_manager_lock.valid_platform(&v.platform).unwrap())
-        .collect::<Vec<GameVersionOption>>();
+        .collect();
     drop(process_manager_lock);
     drop(state_lock);
 
@@ -363,7 +365,7 @@ pub fn on_game_complete(
         .header("Authorization", header)
         .send()?;
 
-    let data = response.json::<GameVersion>()?;
+    let data: GameVersion = response.json()?;
 
     let mut handle = DB.borrow_data_mut().unwrap();
     handle