rpi_host/

manager.rs

use std::time::Duration;

use crate::error::{WifiError, WifiResult};
use crate::nmcli::NmCli;
use crate::types::{
    ConnectionStatus, ConnectivityResult, HotspotConfig, NetworkInfo, WifiMode,
};
use log::{debug, info, warn};

/// Default targets for internet connectivity checks
const DEFAULT_CONNECTIVITY_TARGETS: &[&str] = &[
    "8.8.8.8",        // Google DNS
    "1.1.1.1",        // Cloudflare DNS
    "208.67.222.222", // OpenDNS
];

/// High-level WiFi manager for Raspberry Pi
///
/// Provides an easy-to-use API for switching between client and hotspot modes,
/// scanning networks, and checking internet connectivity.
///
/// # Example
///
/// ```no_run
/// use rpi_host::WifiManager;
///
/// let wifi = WifiManager::new()?;
///
/// // Connect to a network
/// wifi.connect("MyNetwork", Some("password123"))?;
///
/// // Check internet connectivity
/// if wifi.has_internet()? {
///     println!("Connected to the internet!");
/// }
///
/// // Start a hotspot
/// wifi.start_hotspot("MyHotspot", Some("hotspotpass"))?;
/// # Ok::<(), rpi_host::WifiError>(())
/// ```
pub struct WifiManager {
    nmcli: NmCli,
}

impl WifiManager {
    /// Create a new WifiManager using the default interface (wlan0)
    ///
    /// # Errors
    ///
    /// Returns an error if the interface doesn't exist or WiFi is not available.
    pub fn new() -> WifiResult<Self> {
        Self::with_interface("wlan0")
    }

    /// Create a new WifiManager for a specific interface
    ///
    /// # Arguments
    ///
    /// * `interface` - The name of the wireless interface (e.g., "wlan0", "wlan1")
    ///
    /// # Errors
    ///
    /// Returns an error if the interface doesn't exist.
    pub fn with_interface(interface: impl Into<String>) -> WifiResult<Self> {
        let interface = interface.into();
        let nmcli = NmCli::new(&interface);

        // Verify the interface exists
        if !nmcli.interface_exists()? {
            return Err(WifiError::InterfaceNotFound(interface));
        }

        info!("WifiManager initialized for interface: {}", interface);
        Ok(Self { nmcli })
    }

    /// Get the wireless interface name
    pub fn interface(&self) -> &str {
        self.nmcli.interface()
    }

    /// Get the current WiFi mode (Client, Hotspot, or Disconnected)
    pub fn get_mode(&self) -> WifiResult<WifiMode> {
        let active_conn = self.nmcli.get_active_connection()?;

        match active_conn {
            None => Ok(WifiMode::Disconnected),
            Some(_) => {
                if self.nmcli.is_hotspot_active()? {
                    Ok(WifiMode::Hotspot)
                } else {
                    Ok(WifiMode::Client)
                }
            }
        }
    }

    /// Get detailed status of the current connection
    pub fn status(&self) -> WifiResult<ConnectionStatus> {
        let mode = self.get_mode()?;
        let connection_name = self.nmcli.get_active_connection()?;
        let ip_address = self.nmcli.get_ip_address()?;
        let has_internet = if mode == WifiMode::Client {
            self.has_internet().unwrap_or(false)
        } else {
            false
        };

        Ok(ConnectionStatus {
            mode,
            connection_name,
            ip_address,
            has_internet,
            interface: self.interface().to_string(),
        })
    }

    /// Scan for available WiFi networks
    ///
    /// Returns a list of networks sorted by signal strength (strongest first).
    pub fn scan(&self) -> WifiResult<Vec<NetworkInfo>> {
        info!("Scanning for WiFi networks on {}", self.interface());
        self.nmcli.scan_networks()
    }

    /// Connect to a WiFi network as a client
    ///
    /// # Arguments
    ///
    /// * `ssid` - The network name to connect to
    /// * `password` - Optional password for the network
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use rpi_host::WifiManager;
    /// # let wifi = WifiManager::new()?;
    /// // Connect to an open network
    /// wifi.connect("OpenNetwork", None)?;
    ///
    /// // Connect to a secured network
    /// wifi.connect("SecuredNetwork", Some("mypassword"))?;
    /// # Ok::<(), rpi_host::WifiError>(())
    /// ```
    pub fn connect(&self, ssid: impl AsRef<str>, password: Option<&str>) -> WifiResult<()> {
        let ssid = ssid.as_ref();
        info!("Connecting to network: {}", ssid);

        // Ensure WiFi is enabled
        self.ensure_wifi_enabled()?;

        // If currently in hotspot mode, stop it first
        if self.get_mode()? == WifiMode::Hotspot {
            debug!("Stopping active hotspot before connecting");
            self.stop_hotspot()?;
        }

        // Connect to the network
        self.nmcli.connect(ssid, password)?;

        // Wait a moment for connection to establish
        std::thread::sleep(Duration::from_secs(2));

        // Verify connection
        let active = self.nmcli.get_active_connection()?;
        if active.as_deref() == Some(ssid) {
            info!("Successfully connected to {}", ssid);
            Ok(())
        } else {
            Err(WifiError::ConnectionFailed {
                ssid: ssid.to_string(),
                reason: "Connection did not establish".to_string(),
            })
        }
    }

    /// Connect to a WiFi network and wait for internet connectivity
    ///
    /// Similar to `connect()`, but also waits for and verifies internet connectivity.
    ///
    /// # Arguments
    ///
    /// * `ssid` - The network name to connect to
    /// * `password` - Optional password for the network
    /// * `timeout` - Maximum time to wait for internet connectivity
    pub fn connect_with_internet(
        &self,
        ssid: impl AsRef<str>,
        password: Option<&str>,
        timeout: Duration,
    ) -> WifiResult<()> {
        self.connect(ssid.as_ref(), password)?;

        // Wait for internet connectivity
        let start = std::time::Instant::now();
        while start.elapsed() < timeout {
            if self.has_internet()? {
                return Ok(());
            }
            std::thread::sleep(Duration::from_millis(500));
        }

        Err(WifiError::NoInternetConnectivity)
    }

    /// Disconnect from the current network
    pub fn disconnect(&self) -> WifiResult<()> {
        info!("Disconnecting from current network");
        self.nmcli.disconnect()
    }

    /// Start a WiFi hotspot with default settings
    ///
    /// # Arguments
    ///
    /// * `ssid` - The name for the hotspot
    /// * `password` - Optional password (must be at least 8 characters if provided)
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use rpi_host::WifiManager;
    /// # let wifi = WifiManager::new()?;
    /// // Create an open hotspot
    /// wifi.start_hotspot("MyPiHotspot", None)?;
    ///
    /// // Create a secured hotspot
    /// wifi.start_hotspot("MyPiHotspot", Some("password123"))?;
    /// # Ok::<(), rpi_host::WifiError>(())
    /// ```
    pub fn start_hotspot(&self, ssid: impl Into<String>, password: Option<&str>) -> WifiResult<()> {
        let config = HotspotConfig::new(ssid);
        let config = if let Some(pwd) = password {
            config.with_password(pwd)
        } else {
            config
        };
        self.start_hotspot_with_config(config)
    }

    /// Start a WiFi hotspot with custom configuration
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use rpi_host::{WifiManager, HotspotConfig, HotspotBand};
    /// # let wifi = WifiManager::new()?;
    /// let config = HotspotConfig::new("MyHotspot")
    ///     .with_password("securepass")
    ///     .with_band(HotspotBand::A)  // Use 5GHz
    ///     .with_channel(36);
    ///
    /// wifi.start_hotspot_with_config(config)?;
    /// # Ok::<(), rpi_host::WifiError>(())
    /// ```
    pub fn start_hotspot_with_config(&self, config: HotspotConfig) -> WifiResult<()> {
        info!("Starting hotspot: {}", config.ssid);

        // Ensure WiFi is enabled
        self.ensure_wifi_enabled()?;

        // Disconnect from any current connection
        let current_mode = self.get_mode()?;
        if current_mode != WifiMode::Disconnected {
            debug!("Disconnecting from current connection before starting hotspot");
            self.disconnect()?;
            std::thread::sleep(Duration::from_secs(1));
        }

        // Create the hotspot
        self.nmcli.create_hotspot(
            &config.ssid,
            config.password.as_deref(),
            &config.band.to_string(),
            config.channel,
        )?;

        // Wait for hotspot to start
        std::thread::sleep(Duration::from_secs(2));

        // Verify hotspot is active
        if self.nmcli.is_hotspot_active()? {
            info!("Hotspot {} started successfully", config.ssid);
            Ok(())
        } else {
            Err(WifiError::HotspotCreationFailed(
                "Hotspot did not start".to_string(),
            ))
        }
    }

    /// Stop the current hotspot
    pub fn stop_hotspot(&self) -> WifiResult<()> {
        info!("Stopping hotspot");
        self.nmcli.stop_hotspot()
    }

    /// Check if internet is currently available
    ///
    /// Performs a quick connectivity check to verify internet access.
    pub fn has_internet(&self) -> WifiResult<bool> {
        // First try NetworkManager's built-in check
        if let Ok(connected) = self.nmcli.nm_connectivity_check() {
            return Ok(connected);
        }

        // Fall back to ping check
        self.check_connectivity().map(|r| r.is_connected)
    }

    /// Check internet connectivity with detailed results
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use rpi_host::WifiManager;
    /// # let wifi = WifiManager::new()?;
    /// let result = wifi.check_connectivity()?;
    /// if result.is_connected {
    ///     println!("Connected! Latency: {:?}ms", result.latency_ms);
    /// }
    /// # Ok::<(), rpi_host::WifiError>(())
    /// ```
    pub fn check_connectivity(&self) -> WifiResult<ConnectivityResult> {
        self.check_connectivity_to(DEFAULT_CONNECTIVITY_TARGETS[0], Duration::from_secs(5))
    }

    /// Check connectivity to a specific target
    ///
    /// # Arguments
    ///
    /// * `target` - IP address or hostname to ping
    /// * `timeout` - Maximum time to wait for response
    pub fn check_connectivity_to(
        &self,
        target: &str,
        timeout: Duration,
    ) -> WifiResult<ConnectivityResult> {
        debug!("Checking connectivity to {}", target);

        let latency = self.nmcli.check_connectivity(target, timeout.as_secs())?;

        Ok(ConnectivityResult {
            is_connected: latency.is_some(),
            latency_ms: latency,
            target: target.to_string(),
        })
    }

    /// Check connectivity to multiple targets and return true if any succeed
    ///
    /// This is more reliable than checking a single target.
    pub fn check_connectivity_multi(&self, targets: &[&str]) -> WifiResult<bool> {
        for target in targets {
            if let Ok(Some(_)) = self.nmcli.check_connectivity(target, 3) {
                return Ok(true);
            }
        }
        Ok(false)
    }

    /// Wait for internet connectivity with timeout
    ///
    /// Useful after connecting to a network to wait for DHCP and routing to complete.
    pub fn wait_for_internet(&self, timeout: Duration) -> WifiResult<()> {
        let start = std::time::Instant::now();

        while start.elapsed() < timeout {
            if self.has_internet()? {
                return Ok(());
            }
            std::thread::sleep(Duration::from_millis(500));
        }

        Err(WifiError::Timeout(
            "Waiting for internet connectivity".to_string(),
        ))
    }

    /// Enable WiFi if it's currently disabled
    pub fn enable_wifi(&self) -> WifiResult<()> {
        self.nmcli.enable_wifi()
    }

    /// Disable WiFi
    pub fn disable_wifi(&self) -> WifiResult<()> {
        self.nmcli.disable_wifi()
    }

    /// Check if WiFi is enabled
    pub fn is_wifi_enabled(&self) -> WifiResult<bool> {
        self.nmcli.is_wifi_enabled()
    }

    /// Delete a saved network connection profile
    pub fn forget_network(&self, ssid: &str) -> WifiResult<()> {
        info!("Forgetting network: {}", ssid);
        self.nmcli.delete_connection(ssid)
    }

    /// Ensure WiFi is enabled, enabling it if necessary
    fn ensure_wifi_enabled(&self) -> WifiResult<()> {
        if !self.is_wifi_enabled()? {
            warn!("WiFi is disabled, enabling it");
            self.enable_wifi()?;
            std::thread::sleep(Duration::from_secs(1));
        }
        Ok(())
    }
}

impl std::fmt::Debug for WifiManager {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("WifiManager")
            .field("interface", &self.interface())
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // Note: These tests require actual hardware and root permissions to run
    // They are marked as ignored by default

    #[test]
    #[ignore]
    fn test_wifi_manager_creation() {
        let wifi = WifiManager::new();
        assert!(wifi.is_ok());
    }

    #[test]
    #[ignore]
    fn test_scan_networks() {
        let wifi = WifiManager::new().unwrap();
        let networks = wifi.scan();
        assert!(networks.is_ok());
    }

    #[test]
    #[ignore]
    fn test_get_mode() {
        let wifi = WifiManager::new().unwrap();
        let mode = wifi.get_mode();
        assert!(mode.is_ok());
    }
}