chat_core/

stats.rs

use std::collections::{HashMap, HashSet};

#[derive(Debug, Clone, PartialEq)]
pub enum ConnectionStatus {
    Online,
    Offline,
    Connecting,
}

#[derive(Debug, Clone, PartialEq)]
pub struct ConnectionStats {
    pub peer_id: String,
    pub status: ConnectionStatus,
    pub bootstrap_connections: u32,
    pub direct_peers: u32,
    pub relay_connections: u32,
    pub active_transports: Vec<String>,
    pub protocols: Vec<String>,
    pub connected_peers: Vec<String>,
    pub room_peers: Vec<String>,
    pub peer_transports: HashMap<String, Vec<String>>,
    pub peer_addresses: HashMap<String, Vec<String>>,
    pub circuit_address: Option<String>,
    pub web_rtc_address: Option<String>,
}

/// Raw network data returned by [`NetworkNode::raw_stats`](crate::network::NetworkNode).
#[derive(Debug, Clone)]
pub struct RawStats {
    pub peer_id: String,
    pub num_peers: u32,
    pub relay_count: u32,
    pub listeners: Vec<String>,
    pub external_addresses: Vec<String>,
    pub connected_peers: Vec<String>,
    pub peer_conn_addrs: HashMap<String, Vec<String>>,
    pub peer_advertised_addrs: HashMap<String, Vec<String>>,
    pub circuit_address: Option<String>,
    pub web_rtc_address: Option<String>,
}

/// Build a [`ConnectionStats`] from [`RawStats`] and an optional room-peers override.
pub fn build_connection_stats(raw: RawStats, room_peers: Vec<String>) -> ConnectionStats {
    let direct = raw.num_peers.saturating_sub(raw.relay_count);

    let mut transports = HashSet::new();
    for addr in raw.listeners.iter().chain(raw.external_addresses.iter()) {
        let name = transport_name(addr);
        if name != "unknown" {
            transports.insert(name.to_string());
        }
    }

    let mut peer_transports = HashMap::new();
    let mut peer_addresses = HashMap::new();
    for peer_id in &raw.connected_peers {
        let conn_addrs = raw.peer_conn_addrs.get(peer_id).cloned().unwrap_or_default();
        let mut seen = HashSet::new();
        let mut names = Vec::new();
        for addr in &conn_addrs {
            let name = transport_name(addr);
            if name != "unknown" && seen.insert(name) {
                names.push(name.to_string());
            }
        }
        // If active connection addresses yield no recognizable transport,
        // fall back to the peer's advertised listen addresses (Identify).
        if (names.is_empty() || (names.len() == 1 && names[0] == "unknown"))
            && let Some(advertised) = raw.peer_advertised_addrs.get(peer_id)
        {
            for addr in advertised {
                let name = transport_name(addr);
                if name != "unknown" && seen.insert(name) {
                    names.push(name.to_string());
                }
            }
        }
        // Strip useless "unknown" placeholder before sending to UI.
        names.retain(|n| n != "unknown");
        peer_transports.insert(peer_id.clone(), names);
        let addrs = raw.peer_advertised_addrs.get(peer_id).cloned().unwrap_or_default();
        let useful_addrs: Vec<String> = addrs.into_iter().filter(|a| addr_has_transport(a)).collect();
        peer_addresses.insert(peer_id.clone(), useful_addrs);
    }

    ConnectionStats {
        peer_id: raw.peer_id,
        status: if raw.num_peers > 0 {
            ConnectionStatus::Online
        } else {
            ConnectionStatus::Offline
        },
        bootstrap_connections: 0,
        direct_peers: direct,
        relay_connections: raw.relay_count,
        active_transports: transports.into_iter().collect(),
        protocols: vec![],
        connected_peers: raw.connected_peers,
        room_peers,
        peer_transports,
        peer_addresses,
        circuit_address: raw.circuit_address,
        web_rtc_address: raw.web_rtc_address,
    }
}

// ------------------------------------------------------------------
// Minimal transport helpers (kept in core so build_connection_stats
// can compute transport names without depending on libp2p internals).
// ------------------------------------------------------------------

/// Whether a multiaddr string contains at least one transport protocol.
/// Used to reject bare `/p2p/<peer_id>` addresses that have no value for
/// display or dialing.
pub fn addr_has_transport(addr: &str) -> bool {
    addr.contains("webrtc")
        || addr.contains("webtransport")
        || addr.contains("p2p-circuit")
        || addr.contains("wss")
        || addr.contains("ws")
        || addr.contains("tcp")
        || addr.contains("udp")
        || addr.contains("quic")
        || addr.contains("ip4")
        || addr.contains("ip6")
        || addr.contains("dns4")
        || addr.contains("dns6")
        || addr.contains("dns")
}

/// Return a transport keyword for a multiaddr string.
///
/// For circuit-relay addresses the *final* transport (after the relay hop) is
/// reported so the UI shows how the target peer is reachable, not how the
/// relay is reached.
pub fn transport_name(addr: &str) -> &'static str {
    // Circuit-relay addresses may contain an underlying transport name
    // (e.g. webtransport to the relay). We only want to report the
    // direct peer transport, not the hop to the relay.
    if let Some(circuit_pos) = addr.find("p2p-circuit") {
        if let Some(webrtc_pos) = addr.find("webrtc")
            && webrtc_pos > circuit_pos
        {
            return "webrtc";
        }
        if let Some(wt_pos) = addr.find("webtransport")
            && wt_pos > circuit_pos
        {
            return "webtransport";
        }
        return "p2p-circuit";
    }

    if addr.contains("webrtc-direct") {
        "webrtc-direct"
    } else if addr.contains("webrtc") {
        "webrtc"
    } else if addr.contains("webtransport") {
        "webtransport"
    } else if addr.contains("wss") || addr.contains("ws") {
        "websocket"
    } else if addr.contains("tcp") {
        "tcp"
    } else if addr.contains("quic") {
        "quic"
    } else {
        "unknown"
    }
}

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

    #[test]
    fn transport_name_for_webrtc() {
        let addr = "/dns4/example.com/tcp/443/wss/p2p-circuit/webrtc/p2p/12D3KooWGz9xtYbQ8UYj4oRmx4pD3vZvq6T5zN4pMjz6p6V7X8Y9";
        assert_eq!(transport_name(addr), "webrtc");
    }

    #[test]
    fn transport_name_for_wss() {
        let addr = "/dns4/example.com/tcp/443/wss";
        assert_eq!(transport_name(addr), "websocket");
    }

    #[test]
    fn transport_name_for_tcp() {
        let addr = "/ip4/127.0.0.1/tcp/4001";
        assert_eq!(transport_name(addr), "tcp");
    }

    #[test]
    fn transport_name_for_quic() {
        let addr = "/ip4/127.0.0.1/udp/4001/quic-v1";
        assert_eq!(transport_name(addr), "quic");
    }

    #[test]
    fn transport_name_for_webrtc_direct() {
        let addr = "/ip4/127.0.0.1/udp/4001/webrtc-direct/certhash/uEiA...";
        assert_eq!(transport_name(addr), "webrtc-direct");
    }

    #[test]
    fn transport_name_for_relay() {
        let addr = "/dns4/example.com/tcp/443/wss/p2p-circuit/p2p/12D3KooWGz9xtYbQ8UYj4oRmx4pD3vZvq6T5zN4pMjz6p6V7X8Y9";
        assert_eq!(transport_name(addr), "p2p-circuit");
    }

    #[test]
    fn transport_name_for_circuit_over_webtransport() {
        let addr = "/dns4/relay.example.com/udp/443/quic/webtransport/p2p/12D3KooWRelay/p2p-circuit/p2p/12D3KooWTarget";
        assert_eq!(transport_name(addr), "p2p-circuit");
    }

    #[test]
    fn transport_name_for_circuit_over_webrtc_signaling() {
        let addr = "/dns4/relay.example.com/tcp/443/wss/p2p-circuit/webrtc/p2p/12D3KooWTarget";
        assert_eq!(transport_name(addr), "webrtc");
    }

    #[test]
    fn bare_peer_id_has_no_transport() {
        let addr = "/p2p/12D3KooWKLKynHuhH8v2QNgfoj728nZLP83GUZpzeWX8um4VrVGa";
        assert!(!addr_has_transport(addr));
    }

    #[test]
    fn full_multiaddr_has_transport() {
        let addr = "/ip4/127.0.0.1/tcp/4001/p2p/12D3KooWKLKynHuhH8v2QNgfoj728nZLP83GUZpzeWX8um4VrVGa";
        assert!(addr_has_transport(addr));
    }
}