improve: enhanced network overflow handling and cleaner help display

Author: Cod-e-Codes

src/app.rs

@@ -130,7 +130,7 @@ impl App {
             }
             Err(e) => {
                 error!("Failed to read directory {:?}: {}", path, e);
-                vec!["Permission Denied".to_string()]
+                vec![format!("<Error: {}>", e)]
             },
         }
     }
@@ -228,7 +228,7 @@ impl App {
                                 self.selected_network - 1
                             };
                             // Reset network history when switching interfaces
-                            self.network_history = NetworkHistory::new();
+                            self.network_history.clear();
                         }
                     }
                     _ => {}
@@ -254,7 +254,7 @@ impl App {
                         if network_count > 0 {
                             self.selected_network = (self.selected_network + 1) % network_count;
                             // Reset network history when switching interfaces
-                            self.network_history = NetworkHistory::new();
+                            self.network_history.clear();
                         }
                     }
                     _ => {}
@@ -371,8 +371,8 @@ impl App {
                 self.file_list_state.select(Some(0));
             }
         } else if selected_item.starts_with("📁") {
-            // Enter directory
-            let dir_name = selected_item.trim_start_matches("📁 ");
+            // Enter directory - handle truncated names properly
+            let dir_name = selected_item.trim_start_matches("📁 ").trim_end_matches("...");
             let new_path = self.current_dir.join(dir_name);
             if new_path.is_dir() {
                 self.current_dir = new_path;

src/network.rs

@@ -11,26 +11,28 @@ pub struct NetworkHistory {
     pub last_tx_bytes: u64,
     pub max_history: usize,
     pub current_interface: String,
+    pub counter_wrapped: bool,
 }
 
 impl NetworkHistory {
     pub fn new() -> Self {
         Self {
-            rx_history: VecDeque::new(),
-            tx_history: VecDeque::new(),
-            rx_rates: VecDeque::new(),
-            tx_rates: VecDeque::new(),
+            rx_history: VecDeque::with_capacity(NETWORK_HISTORY_SIZE),
+            tx_history: VecDeque::with_capacity(NETWORK_HISTORY_SIZE),
+            rx_rates: VecDeque::with_capacity(NETWORK_HISTORY_SIZE),
+            tx_rates: VecDeque::with_capacity(NETWORK_HISTORY_SIZE),
             last_rx_bytes: 0,
             last_tx_bytes: 0,
-            max_history: NETWORK_HISTORY_SIZE, // Keep 60 data points (2 minutes at 2-second intervals)
+            max_history: NETWORK_HISTORY_SIZE,
             current_interface: String::new(),
+            counter_wrapped: false,
         }
     }
 
     pub fn update(&mut self, networks: &Networks, selected_interface: &str) {
         // Find the selected network interface or use the first available one
-        let network_list: Vec<_> = networks.list().iter().take(100).collect(); // Limit to 100 network interfaces
-        let (interface_name, network_data) = if let Some(item) = network_list.get(0) {
+        let network_list: Vec<_> = networks.list().iter().take(100).collect();
+        let (interface_name, network_data) = if let Some(item) = network_list.first() {
             // If we have a specific interface selected, try to find it
             if !selected_interface.is_empty() {
                 network_list.iter()
@@ -49,20 +51,17 @@ impl NetworkHistory {
         let total_rx = network_data.total_received();
         let total_tx = network_data.total_transmitted();
 
-        if self.last_rx_bytes > 0 && self.last_tx_bytes > 0 {
-            // Calculate rate (bytes per 2 seconds) with overflow detection
-            let rx_rate = if total_rx >= self.last_rx_bytes {
-                total_rx.saturating_sub(self.last_rx_bytes)
-            } else {
-                // Network counter reset or overflow - skip this measurement
-                0
-            };
-            let tx_rate = if total_tx >= self.last_tx_bytes {
-                total_tx.saturating_sub(self.last_tx_bytes)
-            } else {
-                // Network counter reset or overflow - skip this measurement
-                0
-            };
+        // Detect counter wraparound or interface reset
+        if total_rx < self.last_rx_bytes || total_tx < self.last_tx_bytes {
+            self.counter_wrapped = true;
+            self.last_rx_bytes = total_rx;
+            self.last_tx_bytes = total_tx;
+            return; // Skip this measurement entirely
+        }
+
+        if self.last_rx_bytes > 0 && self.last_tx_bytes > 0 && !self.counter_wrapped {
+            let rx_rate = total_rx.saturating_sub(self.last_rx_bytes);
+            let tx_rate = total_tx.saturating_sub(self.last_tx_bytes);
 
             self.rx_rates.push_back(rx_rate);
             self.tx_rates.push_back(tx_rate);
@@ -87,5 +86,16 @@ impl NetworkHistory {
 
         self.last_rx_bytes = total_rx;
         self.last_tx_bytes = total_tx;
+        self.counter_wrapped = false;
+    }
+
+    pub fn clear(&mut self) {
+        self.rx_history.clear();
+        self.tx_history.clear();
+        self.rx_rates.clear();
+        self.tx_rates.clear();
+        self.last_rx_bytes = 0;
+        self.last_tx_bytes = 0;
+        self.counter_wrapped = false;
     }
 }

src/ui/help.rs

@@ -23,9 +23,9 @@ NAVIGATION:
 PANELS:
   1. System Monitor - CPU, Memory, Uptime, Architecture
   2. System Status  - Time, Disk usage, Network stats  
-  3. Process Manager- Top processes (j/k/PgUp/PgDn/Home/End)
-  4. File Explorer  - Navigate directories (j/k/PgUp/PgDn/Home/End + Enter)
-  5. Network Graph  - Real-time network traffic (↑↓ to cycle interfaces)
+  3. Process Manager- Top processes by CPU usage
+  4. File Explorer  - Directory browser with navigation
+  5. Network Graph  - Real-time network traffic graphs
 
 FEATURES:
   • Real-time system monitoring

src/ui/panels.rs

@@ -10,7 +10,7 @@ use chrono::{DateTime, Local};
 use crate::{
     app::App,
     utils::{
-        format_memory_size, format_network_size, format_network_rate, truncate_string,
+        format_memory_size, format_network_size, format_network_rate, truncate_string, format_path_display,
         PROCESS_NAME_MAX_LEN, INTERFACE_NAME_MAX_LEN,
     },
 };
@@ -178,11 +178,7 @@ pub fn render_file_browser(app: &App, frame: &mut Frame, area: Rect, is_selected
         Style::default().fg(Color::White)
     };
 
-    let path_display = if app.current_dir.to_string_lossy().len() > 30 {
-        format!("...{}", app.current_dir.to_string_lossy().chars().rev().take(27).collect::<String>().chars().rev().collect::<String>())
-    } else {
-        app.current_dir.to_string_lossy().to_string()
-    };
+    let path_display = format_path_display(&app.current_dir);
     let title = format!("📂 Explorer: {}", path_display);
 
     let block = Block::default()

src/utils.rs

@@ -11,6 +11,7 @@ pub const MANUAL_REFRESH_COOLDOWN: Duration = Duration::from_millis(500);
 pub const PROCESS_NAME_MAX_LEN: usize = 35;
 pub const INTERFACE_NAME_MAX_LEN: usize = 20;
 pub const FILE_NAME_MAX_LEN: usize = 40;
+pub const MAX_PATH_DISPLAY_LEN: usize = 30;
 
 /// Format memory size in bytes to human-readable string
 pub fn format_memory_size(bytes: u64) -> String {
@@ -56,3 +57,16 @@ pub fn truncate_string(s: &str, max_len: usize) -> String {
         format!("{}...", &s[..max_len.saturating_sub(3)])
     }
 }
+
+/// Format path display with proper character boundary handling
+pub fn format_path_display(path: &std::path::Path) -> String {
+    let path_str = path.to_string_lossy();
+    if path_str.len() <= MAX_PATH_DISPLAY_LEN {
+        path_str.to_string()
+    } else {
+        let chars: Vec<char> = path_str.chars().collect();
+        let take_len = MAX_PATH_DISPLAY_LEN.saturating_sub(3);
+        let start_pos = chars.len().saturating_sub(take_len);
+        format!("...{}", chars[start_pos..].iter().collect::<String>())
+    }
+}