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)
    }
}