p2p_chat/ui/log_mode/input/
commands.rs

1//! This module contains the command execution logic for the log UI mode.
2use crate::ui::log_mode::{LogMode, UIMode};
3use crate::ui::UIState;
4use anyhow::Result;
5use tracing::{debug, Level};
6
7impl LogMode {
8    /// Executes a command entered by the user in log mode.
9    ///
10    /// This function parses the input string and dispatches various log-related
11    /// commands, such as setting the log level, filtering logs, clearing the buffer,
12    /// or displaying a tail of the logs.
13    ///
14    /// # Arguments
15    ///
16    /// * `input` - The command string entered by the user.
17    /// * `state` - The current UI state, which will be modified based on the command.
18    ///
19    /// # Errors
20    ///
21    /// This function returns an error if command execution fails due to unexpected issues.
22    pub(crate) async fn execute_log_command(&self, input: &str, state: &mut UIState) -> Result<()> {
23        let parts: Vec<&str> = input.split_whitespace().collect();
24        if parts.is_empty() {
25            return Ok(());
26        }
27
28        match parts[0] {
29            "level" => {
30                if parts.len() >= 2 {
31                    let level_str = parts[1].to_lowercase();
32                    let new_level = match level_str.as_str() {
33                        "trace" => Level::TRACE,
34                        "debug" => Level::DEBUG,
35                        "info" => Level::INFO,
36                        "warn" => Level::WARN,
37                        "error" => Level::ERROR,
38                        _ => {
39                            debug!(
40                                "Invalid log level: {}. Use trace/debug/info/warn/error",
41                                parts[1]
42                            );
43                            return Ok(());
44                        }
45                    };
46
47                    if let UIMode::Logs { filter, .. } = state.mode.clone() {
48                        state.mode = UIMode::Logs {
49                            filter,
50                            level: new_level,
51                        };
52                    }
53                    debug!("Log level set to: {:?}", new_level);
54                } else {
55                    debug!("Usage: level <trace|debug|info|warn|error>");
56                }
57            }
58            "filter" => {
59                if parts.len() >= 2 {
60                    let filter = parts[1..].join(" ");
61                    if let UIMode::Logs { level, .. } = state.mode.clone() {
62                        state.mode = UIMode::Logs {
63                            filter: Some(filter.clone()),
64                            level,
65                        };
66                    }
67                    debug!("Log filter set to: {}", filter);
68                } else if let UIMode::Logs { level, .. } = state.mode.clone() {
69                    state.mode = UIMode::Logs {
70                        filter: None,
71                        level,
72                    };
73                    debug!("Log filter cleared");
74                }
75            }
76            "clear" => {
77                state.logs.clear();
78                state.log_scroll_offset = 0;
79                debug!("Log buffer cleared");
80            }
81            "tail" => {
82                if parts.len() >= 2 {
83                    if let Ok(count) = parts[1].parse::<usize>() {
84                        let keep_count = count.min(state.logs.len());
85                        let remove_count = state.logs.len() - keep_count;
86                        for _ in 0..remove_count {
87                            state.logs.pop_front();
88                        }
89                        state.log_scroll_offset = 0;
90                        debug!("Showing last {} log entries", keep_count);
91                    } else {
92                        debug!("Usage: tail <number>");
93                    }
94                } else {
95                    debug!("Usage: tail <number>");
96                }
97            }
98            "export" => {
99                if parts.len() >= 2 {
100                    debug!("Log export not yet implemented: {}", parts[1]);
101                } else {
102                    debug!("Usage: export <filename>");
103                }
104            }
105            "help" => {
106                debug!(
107                    "Log commands: level <level>, filter <text>, clear, tail <n>, export <file>"
108                );
109            }
110            _ => {
111                debug!(
112                    "Unknown log command: {}. Type 'help' for available commands.",
113                    parts[0]
114                );
115            }
116        }
117
118        Ok(())
119    }
120}