Initial commit: FunConnect project with server, relay, client and admin panel

Co-authored-by: Cursor <cursoragent@cursor.com>

client/src/state.rs

@@ -0,0 +1,77 @@
+use serde::{Deserialize, Serialize};
+use std::sync::{Arc, Mutex};
+use tokio::sync::RwLock;
+use uuid::Uuid;
+
+use crate::network::session::NetworkSession;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CurrentUser {
+    pub id: Uuid,
+    pub username: String,
+    pub email: String,
+    pub avatar_seed: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Tokens {
+    pub access_token: String,
+    pub refresh_token: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ServerConfig {
+    pub server_name: String,
+    pub server_url: String,
+    pub relay_url: String,
+    #[serde(default)]
+    pub version: String,
+}
+
+pub struct AppState {
+    pub server_url: Mutex<String>,
+    pub server_config: Mutex<Option<ServerConfig>>,
+    pub user: Mutex<Option<CurrentUser>>,
+    pub tokens: Mutex<Option<Tokens>>,
+    pub network_session: Arc<RwLock<Option<NetworkSession>>>,
+}
+
+impl AppState {
+    pub fn new() -> Self {
+        let server_url = std::env::var("FUNMC_SERVER")
+            .unwrap_or_else(|_| "http://localhost:3000".into());
+        Self {
+            server_url: Mutex::new(server_url),
+            server_config: Mutex::new(None),
+            user: Mutex::new(None),
+            tokens: Mutex::new(None),
+            network_session: Arc::new(RwLock::new(None)),
+        }
+    }
+
+    pub fn get_server_url(&self) -> String {
+        self.server_url.lock().unwrap().clone()
+    }
+
+    pub fn set_server_url(&self, url: String) {
+        *self.server_url.lock().unwrap() = url;
+    }
+
+    pub fn get_access_token(&self) -> Option<String> {
+        self.tokens.lock().ok()?.as_ref().map(|t| t.access_token.clone())
+    }
+
+    pub fn set_auth(&self, user: CurrentUser, tokens: Tokens) {
+        *self.user.lock().unwrap() = Some(user);
+        *self.tokens.lock().unwrap() = Some(tokens);
+    }
+
+    pub fn clear_auth(&self) {
+        *self.user.lock().unwrap() = None;
+        *self.tokens.lock().unwrap() = None;
+    }
+
+    pub fn get_user_id(&self) -> Option<Uuid> {
+        self.user.lock().ok()?.as_ref().map(|u| u.id)
+    }
+}