update to use proper config manager

src-tauri/src/frontend_calls/close_splashscreen.rs

···
 use std::env;
-use tauri::{ Emitter, Manager };
+use tauri::{ Emitter, Manager, State };
+
+use crate::frontend_calls::config::Config;
 
 use super::config::get_config_value_string;
 
 #[tauri::command]
-pub fn close_splashscreen( window: tauri::Window ) {
+pub fn close_splashscreen( window: tauri::Window, config: State<Config> ) {
   let args: Vec<String> = env::args().collect();
 
   let mut show = true;
···
     }
   }
 
-  let value: String = match get_config_value_string("start-in-bg".to_owned()) { Some(val) => val, None => "false".to_owned() };
+  let value: String = match get_config_value_string("start-in-bg".to_owned(), config) { Some(val) => val, None => "false".to_owned() };
   if value == "true"{
     show = false;
   }

src-tauri/src/frontend_calls/config.rs

···
-use std::{fs, path::PathBuf};
+use std::{fs, path::PathBuf, sync::Mutex};
 
 use serde_json::Value;
+use tauri::State;
 
 pub fn get_config_path() -> PathBuf {
   let path = dirs::config_dir()
···
   path
 }
 
+pub struct Config{
+  config: Mutex<Value>
+}
 
-// TODO: Redo all of this just, stop please.
-#[tauri::command]
-pub fn set_config_value_string(key: String, value: String) {
-  let path = get_config_path();
+impl Config{
+  pub fn new() -> Config{
+    let path = get_config_path();
+    let config: Value = serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
+
+    Config {
+      config: Mutex::new(config)
+    }
+  }
+
+  pub fn set( &self, key: String, value: Value ){
+    let mut lock = self.config.lock().unwrap();
+    lock[key] = value;
+  }
+
+  pub fn get( &self, key: String ) -> Value{
+    let lock = self.config.lock().unwrap();
+    lock[key].clone()
+  }
+
+  pub fn save( &self ){
+    let path = get_config_path();
+    let string = serde_json::to_string(&self.config).unwrap();
 
-  let mut config: Value = serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
-  config[key] = Value::from(value);
+    fs::write(path, string).unwrap();
+  }
+}
 
-  fs::write(path, config.to_string()).unwrap();
+#[tauri::command]
+pub fn set_config_value_string( key: String, value: String, config: State<Config> ) {
+  config.set(key, Value::from(value));
 }
 
 #[tauri::command]
-pub fn get_config_value_string(key: String) -> Option<String> {
-  let config: Value =
-    serde_json::from_str(&fs::read_to_string(get_config_path()).unwrap()).unwrap();
-  let string = config[key].as_str();
+pub fn get_config_value_string( key: String, config: State<Config> ) -> Option<String> {
+  let string = config.get(key);
+  let string = string.as_str();
 
   if string.is_some() {
     Some(string.unwrap().to_owned())
···
 }
 
 #[tauri::command]
-pub fn set_config_value_int(key: String, value: i64) {
-  let path = get_config_path();
-
-  let mut config: Value = serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
-  config[key] = Value::from(value);
-
-  fs::write(path, config.to_string()).unwrap();
+pub fn set_config_value_int( key: String, value: i64, config: State<Config> ) {
+  config.set(key, Value::from(value));
 }
 
 #[tauri::command]
-pub fn get_config_value_int(key: String) -> Option<i64> {
-  let config: Value =
-    serde_json::from_str(&fs::read_to_string(get_config_path()).unwrap()).unwrap();
-  config[key].as_i64()
+pub fn get_config_value_int( key: String, config: State<Config> ) -> Option<i64> {
+  let string = config.get(key);
+  string.as_i64()
 }

src-tauri/src/main.rs

···
 use tauri::{ Emitter, Manager, State, WindowEvent };
 use tauri_plugin_deep_link::DeepLinkExt;
 
-use crate::frontend_calls::config::get_config_value_string;
+use crate::frontend_calls::config::{get_config_value_string, Config};
 
 fn main() {
   #[cfg(target_os = "linux")]
···
     })
     .on_window_event(|window, event| match event {
       WindowEvent::CloseRequested { api,   .. } => {
-        let val = get_config_value_string("minimise-on-close".into());
-        if val.is_some() && val.unwrap() == "false"{ return; }
+        let config: State<Config> = window.state();
+
+        let val = get_config_value_string("minimise-on-close".into(), config.clone());
+        if val.is_some() && val.unwrap() == "false"{
+          config.save();
+          return;
+        }
 
         window.hide().unwrap();
         api.prevent_close();
       }
       _ => {}
     })
+    .manage(Config::new())
     .manage(cache)
     .manage(Mutex::new(clipboard))
     .setup(|app| {

src-tauri/src/util/cache.rs

···
-use std::{collections::HashMap, sync::Mutex};
+use std::{ collections::HashMap, sync::Mutex };
 
 pub struct Cache{
   store: Mutex<HashMap<String, String>>,

src-tauri/src/util/setup_traymenu.rs

···
 use tauri::{
   menu::{MenuBuilder, MenuItemBuilder},
   tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
-  AppHandle, Emitter, Manager,
+  AppHandle, Emitter, Manager, State,
 };
+
+use crate::frontend_calls::config::Config;
 
 #[derive(serde::Serialize, Clone)]
 struct EmptyEvent {}
···
     .tooltip("VRChat Photo Manager")
     .on_menu_event(move |app: &AppHandle, event| match event.id().as_ref() {
       "quit" => {
+        let config: State<Config> = app.state();
+        config.save();
+
         std::process::exit(0);
       }
       "hide" => {