// in app-core/src/state.rs
use crate::{
    lock_r,
    lock_w,
    models::{app_data::UserData, dolls::DollDto},
    services::{
        cursor::CursorPositions,
        presence_modules::models::ModuleMetadata,
    },
};
use std::collections::{HashMap, HashSet};
use std::sync::{Arc, LazyLock, RwLock};
use tauri::tray::TrayIcon;
use tracing::info;

pub mod auth;
mod network;
mod ui;

pub use auth::*;
pub use network::*;
pub use ui::*;

#[derive(Default)]
pub struct Modules {
    pub handles: std::sync::Mutex<Vec<std::thread::JoinHandle<()>>>,
    pub metadatas: Vec<ModuleMetadata>,
}

#[derive(Default, Clone)]
pub struct FriendSceneRuntimeState {
    pub cursor_positions: HashMap<String, CursorPositions>,
    pub active_dolls: HashMap<String, Option<DollDto>>,
}

#[derive(Default, Clone)]
pub struct PresenceRuntimeState {
    pub current: Option<crate::models::event_payloads::UserStatusPayload>,
    pub friends: HashMap<String, crate::models::event_payloads::UserStatusPayload>,
}

#[derive(Default)]
pub struct AppState {
    pub app_config: crate::services::client_config_manager::AppConfig,
    pub network: NetworkState,
    pub auth: AuthState,
    pub user_data: UserData,
    pub friend_scene: FriendSceneRuntimeState,
    pub presence: PresenceRuntimeState,
    pub tray: Option<TrayIcon>,
    pub modules: Modules,
}

// Global application state
// Read / write this state via the `lock_r!` / `lock_w!` macros from `fdoll-core::utilities`
pub static FDOLL: LazyLock<Arc<RwLock<AppState>>> =
    LazyLock::new(|| Arc::new(RwLock::new(AppState::default())));

pub fn get_known_friend_ids() -> HashSet<String> {
    let guard = lock_r!(FDOLL);

    guard
        .user_data
        .friends
        .as_ref()
        .map(|friends| {
            friends
                .iter()
                .filter_map(|friendship| friendship.friend.as_ref().map(|friend| friend.id.clone()))
                .collect()
        })
        .unwrap_or_default()
}

/// Populate app state with initial
/// values and necesary client instances.
pub fn init_app_state() {
    dotenvy::dotenv().ok();
    {
        let mut guard = lock_w!(FDOLL);
        guard.app_config = crate::services::client_config_manager::load_app_config();
        guard.network = init_network_state();
        guard.auth = init_auth_state();
        guard.user_data = UserData::default();
        guard.friend_scene = FriendSceneRuntimeState::default();
        guard.presence = PresenceRuntimeState::default();
        guard.modules = Modules::default();
    }
    update_display_dimensions_for_scene_state();
    info!("Initialized FDOLL state (WebSocket client & user data initializing asynchronously)");
}