tauri-plugin-network-manager 2.1.1

use tauri::{AppHandle, Manager};

use crate::{NetworkError, NetworkManagerState};
use crate::models::{
    NetworkInfo, WiFiConnectionConfig, VpnCreateConfig, VpnProfile, VpnStatus, VpnUpdateConfig,
};
use crate::error::Result;

/// Get the current network state
#[tauri::command]
pub async fn get_network_state(app_handle: AppHandle) -> Result<NetworkInfo> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    let manager = state.manager.read().map_err(|_| NetworkError::LockError)?;

    match manager.as_ref() {
        Some(manager) => {
            let result = manager.get_current_network_state();
            result
        },
        _ => Err(NetworkError::NotInitialized),
    }
}

/// List available WiFi networks
#[tauri::command]
pub async fn list_wifi_networks(
    app_handle: AppHandle,
    force_refresh: Option<bool>,
    ttl_ms: Option<u64>,
) -> Result<Vec<NetworkInfo>> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.list_wifi_networks(force_refresh.unwrap_or(false), ttl_ms)
}

/// Trigger a WiFi rescan and return a fresh list
#[tauri::command]
pub fn rescan_wifi(app_handle: AppHandle) -> Result<Vec<NetworkInfo>> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.rescan_wifi()
}

/// Connect to a WiFi network
#[tauri::command]
pub fn connect_to_wifi(app_handle: AppHandle, config: WiFiConnectionConfig) -> Result<()> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.connect_to_wifi(config)?;
    Ok(())
}

/// Disconnect from the current WiFi network
#[tauri::command]
pub fn disconnect_from_wifi(app_handle: AppHandle) -> Result<()> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.disconnect_from_wifi()?;
    Ok(())
}

/// Get saved WiFi networks
#[tauri::command]
pub async fn get_saved_wifi_networks(app_handle: AppHandle) -> Result<Vec<NetworkInfo>> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.get_saved_wifi_networks()
}

/// Delete a WiFi connection by SSID
#[tauri::command]
pub fn delete_wifi_connection(app_handle: AppHandle, ssid: &str) -> Result<()> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    let deleted = state.delete_wifi_connection(ssid)?;
    if !deleted {
        return Err(NetworkError::OperationError(format!(
            "No saved WiFi connection found for SSID '{}'",
            ssid
        )));
    }
    Ok(())
}

/// Toggle network on or off
#[tauri::command]
pub fn toggle_network_state(app_handle: AppHandle, enabled: bool) -> Result<()> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.toggle_network_state(enabled)?;
    Ok(())
}

#[tauri::command]
pub fn get_wireless_enabled(app_handle: AppHandle) -> Result<bool> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    Ok(state.get_wireless_enabled()?)
}

#[tauri::command]
pub fn set_wireless_enabled(app_handle: AppHandle, enabled: bool) -> Result<()> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    Ok(state.set_wireless_enabled(enabled)?)
}

#[tauri::command]
pub fn is_wireless_available(app_handle: AppHandle) -> Result<bool> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    Ok(state.is_wireless_available()?)
}

/// Get network statistics for the active interface
#[tauri::command]
pub fn get_network_stats(app_handle: AppHandle) -> Result<crate::models::NetworkStats> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.get_network_stats()
}

/// Get list of available network interfaces
#[tauri::command]
pub fn get_network_interfaces() -> Result<Vec<String>> {
    crate::network_stats::get_network_interfaces()
        .map_err(|e| NetworkError::from(e))
}

/// List saved VPN profiles
#[tauri::command]
pub fn list_vpn_profiles(app_handle: AppHandle) -> Result<Vec<VpnProfile>> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.list_vpn_profiles()
}

/// Get current VPN status
#[tauri::command]
pub fn get_vpn_status(app_handle: AppHandle) -> Result<VpnStatus> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.get_vpn_status()
}

/// Connect VPN by profile UUID
#[tauri::command]
pub fn connect_vpn(app_handle: AppHandle, uuid: String) -> Result<()> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.connect_vpn(uuid)
}

/// Disconnect active VPN or specific profile UUID if provided
#[tauri::command]
pub fn disconnect_vpn(app_handle: AppHandle, uuid: Option<String>) -> Result<()> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.disconnect_vpn(uuid)
}

/// Create a VPN profile
#[tauri::command]
pub fn create_vpn_profile(app_handle: AppHandle, config: VpnCreateConfig) -> Result<VpnProfile> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.create_vpn_profile(config)
}

/// Update a VPN profile
#[tauri::command]
pub fn update_vpn_profile(app_handle: AppHandle, config: VpnUpdateConfig) -> Result<VpnProfile> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.update_vpn_profile(config)
}

/// Delete VPN profile by UUID
#[tauri::command]
pub fn delete_vpn_profile(app_handle: AppHandle, uuid: String) -> Result<()> {
    let state = app_handle.state::<NetworkManagerState<tauri::Wry>>();
    state.delete_vpn_profile(uuid)
}