/// Utilitaires pour la gestion des adresses IP réseau.
///
/// Ce module fournit des fonctions pour détecter et lister les adresses IP
/// des interfaces réseau locales de la machine.
///
/// # Fonctions principales
///
/// - [`guess_local_ip`] : Devine l'adresse IP locale utilisée pour les connexions sortantes
/// - [`guess_local_ip_with_timeout`] : Version avec timeout configurable
/// - `list_all_ips` : Liste toutes les adresses IP non-loopback des interfaces réseau
///
/// # Examples
///
/// ```
/// use pmoutils::guess_local_ip;
/// use pmoutils::ip_utils::list_all_ips;
///
/// let ip = guess_local_ip();
/// println!("Adresse IP locale: {}", ip);
///
/// let ips = list_all_ips();
/// for (interface, addresses) in ips.iter() {
///     println!("Interface {}: {:?}", interface, addresses);
/// }
/// ```
pub mod ip_utils;

pub use ip_utils::{guess_local_ip, guess_local_ip_with_timeout};

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

    #[test]
    fn test_get_os_string_contains_os_type() {
        let os = get_os_string();
        // Les types d'OS retournés par os_info peuvent varier, on vérifie juste le format
        let parts: Vec<&str> = os.split('/').collect();
        assert_eq!(
            parts.len(),
            2,
            "OS string should have format 'Type/Version'"
        );
        assert!(!parts[0].is_empty(), "OS type should not be empty");
        assert!(!parts[1].is_empty(), "OS version should not be empty");
    }
}

/// Utilitaires pour la gestion des processus et des ports réseau.
///
/// Ce module fournit des fonctions pour identifier les processus qui utilisent
/// des ports réseau spécifiques.
///
/// # Fonctions principales
///
/// - [`find_process_using_port`] : Trouve le processus qui écoute sur un port donné
/// - [`ProcessPortInfo`] : Structure contenant les informations d'un processus
/// - [`TransportProtocol`] : Énumération des protocoles TCP et UDP
///
/// # Examples
///
/// ```
/// use pmoutils::{find_process_using_port, TransportProtocol};
///
/// let info = find_process_using_port(TransportProtocol::Tcp, 8080);
///
/// if let Some(process_info) = info {
///     println!("PID: {}", process_info.pid);
///     println!("Nom: {}", process_info.process_name);
///     println!("Propriétaire: {}", process_info.owner);
/// }
/// ```
pub mod process;

pub use process::{find_process_using_port, ProcessPortInfo, TransportProtocol};

/// Retourne une chaîne décrivant le système d'exploitation et sa version.
///
/// Utilise la crate `os_info` pour obtenir de manière portable et fiable
/// les informations sur le système d'exploitation courant.
///
/// # Format
///
/// - macOS: "macOS/15.1" ou "Mac OS/10.15.7"
/// - Linux: "Linux/6.5.0" ou "Ubuntu/22.04"
/// - Windows: "Windows/10.0.19045"
/// - Autre: "{OS}/Unknown"
///
/// # Returns
///
/// Une chaîne de caractères au format "Type/Version".
///
/// # Examples
///
/// ```
/// use pmoutils::get_os_string;
///
/// let os = get_os_string();
/// println!("OS: {}", os); // Ex: "Linux/6.5.0"
/// ```
pub fn get_os_string() -> String {
    let info = os_info::get();
    let os_type = format!("{:?}", info.os_type());

    // Obtenir la version si disponible
    let version = info.version();
    if version != &os_info::Version::Unknown {
        format!("{}/{}", os_type, version)
    } else {
        format!("{}/Unknown", os_type)
    }
}