piopulse 1.0.0

A terminal user interface (TUI) embedded debugger for serial debugging, telemetry plotting, dashboards, and ESP32 flashing.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296

use crate::app::App;
use crate::ui::tr;
use ratatui::{
    Frame,
    layout::{Constraint, Direction, Layout, Rect},
    style::{Modifier, Style},
    text::{Line, Span},
    widgets::{Block, BorderType, Borders, Paragraph},
};

use crate::ui::theme::{CATPPUCCIN_MOCHA, mocha};

pub fn draw(f: &mut Frame, app: &mut App, area: Rect) {
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([Constraint::Length(8), Constraint::Min(5)])
        .split(area);

    app.layout_zones.monitor_panel = chunks[1];
    app.layout_zones.flash_summary = chunks[0];

    draw_stats(f, app, chunks[0]);
    crate::ui::channels::draw_guided_burning_panel(f, app, chunks[1]);
}

fn draw_stats(f: &mut Frame, app: &App, area: Rect) {
    let lang = &app.tool_config.language;
    let stats_block = Block::default()
        .borders(Borders::ALL)
        .border_type(BorderType::Rounded)
        .border_style(Style::default().fg(CATPPUCCIN_MOCHA.border))
        .title(Span::styled(
            tr("sidebar_stats_title", lang),
            Style::default()
                .fg(CATPPUCCIN_MOCHA.text)
                .add_modifier(Modifier::BOLD),
        ));
    let inner_area = stats_block.inner(area);

    let total = app.stats.total_passed + app.stats.total_failed;
    let yield_rate = if total > 0 {
        (app.stats.total_passed as f32 / total as f32) * 100.0
    } else {
        0.0
    };

    let elapsed_str = format!(
        "{:02}:{:02}",
        app.elapsed_time.as_secs() / 60,
        app.elapsed_time.as_secs() % 60
    );

    let total_str = app.stats.total_attempted.to_string();
    let yield_str = format!("{:.1}%", yield_rate);
    let passed_str = app.stats.total_passed.to_string();
    let failed_str = app.stats.total_failed.to_string();

    let attempt_label = tr("sidebar_total_attempted", lang);
    let yield_label = tr("sidebar_yield_rate", lang);
    let passed_label = tr("sidebar_passed", lang);
    let failed_label = tr("sidebar_failed", lang);
    let elapsed_label_str = tr("sidebar_elapsed_time", lang);

    // Dynamic padding calculation for dual-column alignment
    let col1_left = format!("{}{}", attempt_label, total_str);
    let col1_right = format!("{}{}", yield_label, yield_str);
    let pad1 = (inner_area.width as usize).saturating_sub(col1_left.len() + col1_right.len());

    let col2_left = format!("{}{}", passed_label, passed_str);
    let col2_right = format!("{}{}", failed_label, failed_str);
    let pad2 = (inner_area.width as usize).saturating_sub(col2_left.len() + col2_right.len());

    let mut stats_text = vec![
        Line::from(vec![
            Span::styled(attempt_label, Style::default().fg(CATPPUCCIN_MOCHA.text_muted)),
            Span::styled(total_str, Style::default().fg(CATPPUCCIN_MOCHA.text).add_modifier(Modifier::BOLD)),
            Span::raw(" ".repeat(pad1.max(2))),
            Span::styled(yield_label, Style::default().fg(CATPPUCCIN_MOCHA.text_muted)),
            Span::styled(
                yield_str,
                Style::default()
                    .fg(if yield_rate >= 95.0 || total == 0 {
                        CATPPUCCIN_MOCHA.success
                    } else {
                        CATPPUCCIN_MOCHA.danger
                    })
                    .add_modifier(Modifier::BOLD),
            ),
        ]),
        Line::from(vec![
            Span::styled(passed_label, Style::default().fg(CATPPUCCIN_MOCHA.text_muted)),
            Span::styled(passed_str, Style::default().fg(CATPPUCCIN_MOCHA.success).add_modifier(Modifier::BOLD)),
            Span::raw(" ".repeat(pad2.max(2))),
            Span::styled(failed_label, Style::default().fg(CATPPUCCIN_MOCHA.text_muted)),
            Span::styled(failed_str, Style::default().fg(CATPPUCCIN_MOCHA.danger).add_modifier(Modifier::BOLD)),
        ]),
        Line::from(vec![
            Span::styled(elapsed_label_str, Style::default().fg(CATPPUCCIN_MOCHA.text_muted)),
            Span::styled(elapsed_str, Style::default().fg(CATPPUCCIN_MOCHA.text)),
        ]),
    ];

    // Separator line
    let sep_char = "─";
    stats_text.push(Line::from(Span::styled(
        sep_char.repeat(inner_area.width as usize),
        Style::default().fg(CATPPUCCIN_MOCHA.border),
    )));

    // Render the outer block
    f.render_widget(stats_block, area);

    // Split inner_area vertically
    let vertical_chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(4), // Stats text + separator line
            Constraint::Length(2), // Buttons rows
        ])
        .split(inner_area);

    // Render stats text
    let stats_widget = Paragraph::new(stats_text)
        .block(Block::default())
        .style(Style::default().bg(CATPPUCCIN_MOCHA.panel));
    f.render_widget(stats_widget, vertical_chunks[0]);

    // Get the button rects from app
    let rects = app.get_flash_summary_button_rects();

    // Set up button labels
    let b0_label = if lang == "zh" { "开始烧录" } else { "Start Flash" };
    let b1_label = if app.flash_batch_mode {
        if lang == "zh" { "模式: 批量" } else { "Mode: Batch" }
    } else {
        if lang == "zh" { "模式: 单台" } else { "Mode: Single" }
    };
    let b2_label = if lang == "zh" { "自动感应" } else { "Auto Flash" };
    let b3_label = if lang == "zh" { "清空累计" } else { "Clear Stats" };

    // Button colors
    let b0_color = CATPPUCCIN_MOCHA.primary;
    let b1_color = CATPPUCCIN_MOCHA.accent;
    let b2_color = if app.auto_flash {
        CATPPUCCIN_MOCHA.success
    } else {
        CATPPUCCIN_MOCHA.text_muted
    };
    let b3_color = CATPPUCCIN_MOCHA.danger;

    // Helper closure to render buttons
    let render_btn = |f: &mut Frame, rect: Rect, label: &str, is_hovered: bool, color: ratatui::style::Color| {
        let text = if is_hovered {
            let pad_w = (rect.width as usize).saturating_sub(unicode_width::UnicodeWidthStr::width(label));
            let pad_left = pad_w / 2;
            let pad_right = pad_w - pad_left;
            let padded_label = format!("{}{}{}", " ".repeat(pad_left), label, " ".repeat(pad_right));
            Line::from(vec![
                Span::styled(padded_label, Style::default().fg(mocha::BASE).bg(color).add_modifier(Modifier::BOLD)),
            ])
        } else {
            let content_w = (rect.width as usize).saturating_sub(4);
            let label_w = unicode_width::UnicodeWidthStr::width(label);
            let pad_w = content_w.saturating_sub(label_w);
            let pad_left = pad_w / 2;
            let pad_right = pad_w - pad_left;
            let padded_label = format!("{}{}{}", " ".repeat(pad_left), label, " ".repeat(pad_right));
            Line::from(vec![
                Span::styled("[ ", Style::default().fg(CATPPUCCIN_MOCHA.border)),
                Span::styled(padded_label, Style::default().fg(color).add_modifier(Modifier::BOLD)),
                Span::styled(" ]", Style::default().fg(CATPPUCCIN_MOCHA.border)),
            ])
        };
        let btn_widget = Paragraph::new(text);
        f.render_widget(btn_widget, rect);
    };

    // Render the 4 buttons
    if rects.len() >= 4 {
        render_btn(f, rects[0], b0_label, app.hover_flash_action == Some(0), b0_color);
        render_btn(f, rects[1], b1_label, app.hover_flash_action == Some(1), b1_color);
        render_btn(f, rects[2], b2_label, app.hover_flash_action == Some(2), b2_color);
        render_btn(f, rects[3], b3_label, app.hover_flash_action == Some(3), b3_color);
    }
}

#[allow(dead_code)]
fn wrap_log_line(line: &str, max_width: usize) -> Vec<String> {
    if max_width == 0 {
        return vec![line.to_string()];
    }
    let mut result = Vec::new();
    let mut current = String::new();

    for word in line.split_whitespace() {
        if current.is_empty() {
            if word.len() <= max_width {
                current.push_str(word);
            } else {
                let chars: Vec<char> = word.chars().collect();
                for chunk in chars.chunks(max_width) {
                    let s: String = chunk.iter().collect();
                    if current.is_empty() {
                        current = s;
                    } else {
                        result.push(current);
                        current = s;
                    }
                }
            }
        } else {
            if current.len() + 1 + word.len() <= max_width {
                current.push(' ');
                current.push_str(word);
            } else {
                result.push(current);
                current = String::new();
                if word.len() <= max_width {
                    current.push_str(word);
                } else {
                    let chars: Vec<char> = word.chars().collect();
                    for chunk in chars.chunks(max_width) {
                        let s: String = chunk.iter().collect();
                        if current.is_empty() {
                            current = s;
                        } else {
                            result.push(current);
                            current = s;
                        }
                    }
                }
            }
        }
    }
    if !current.is_empty() {
        result.push(current);
    }
    if result.is_empty() {
        result.push(String::new());
    }
    result
}

#[allow(dead_code)]
fn draw_serial_monitor(f: &mut Frame, app: &App, area: Rect) {
    let lang = &app.tool_config.language;
    let block = Block::default()
        .borders(Borders::ALL)
        .border_type(BorderType::Rounded)
        .border_style(Style::default().fg(CATPPUCCIN_MOCHA.border))
        .title(Span::styled(
            tr("sidebar_monitor_title", lang),
            Style::default()
                .fg(CATPPUCCIN_MOCHA.text)
                .add_modifier(Modifier::BOLD),
        ));

    let inner_area = block.inner(area);
    f.render_widget(block, area);

    let max_width = (inner_area.width as usize).saturating_sub(1);
    let mut wrapped_lines: Vec<Line> = Vec::new();

    for log in &app.logs {
        let fg_color = if log.contains("FAILED") || log.contains("failed") || log.contains("Error")
        {
            CATPPUCCIN_MOCHA.danger
        } else if log.contains("SUCCESS") || log.contains("PASSED") || log.contains("Success") {
            CATPPUCCIN_MOCHA.success
        } else {
            CATPPUCCIN_MOCHA.text_muted
        };

        let sub_lines = wrap_log_line(log, max_width);
        for sub_line in sub_lines {
            wrapped_lines.push(Line::from(Span::styled(
                sub_line,
                Style::default().fg(fg_color),
            )));
        }
    }

    let height = inner_area.height as usize;
    let logs_to_draw = if wrapped_lines.len() > height {
        let start = wrapped_lines.len() - height;
        wrapped_lines[start..].to_vec()
    } else {
        wrapped_lines
    };

    let logs_widget = Paragraph::new(logs_to_draw)
        .block(Block::default())
        .style(Style::default().bg(mocha::MANTLE));

    f.render_widget(logs_widget, inner_area);
}