1use crate::core::prelude::*;
2use crate::ui::color::AppColor;
3use crate::ui::cursor::{CursorKind, UiCursor};
4use crate::ui::viewport::{ScrollDirection, Viewport, ViewportEvent};
5use ratatui::{
6 style::Style,
7 text::{Line, Span},
8 widgets::{Block, Borders, Paragraph, Wrap},
9};
10use strip_ansi_escapes::strip;
11use unicode_segmentation::UnicodeSegmentation;
12
13#[derive(Debug)]
14pub struct Message {
15 pub content: String,
16 pub current_length: usize,
17 pub timestamp: Instant,
18 pub line_count: usize,
19 pub typewriter_cursor: Option<UiCursor>,
20}
21
22#[derive(Debug, Clone)]
23struct CachedLine {
24 content: String,
25 message_index: usize,
26 is_partial: bool,
27 visible_chars: usize,
28}
29
30type RenderData<'a> = (
31 Vec<(String, usize, bool, bool, bool)>,
32 Config,
33 crate::ui::viewport::LayoutArea,
34 &'a UiCursor,
35);
36
37impl Message {
38 pub fn new(content: String, typewriter_delay: Duration) -> Self {
39 let (initial_length, typewriter_cursor) = if typewriter_delay.as_millis() == 0 {
40 (content.graphemes(true).count(), None)
41 } else {
42 (0, Some(UiCursor::for_typewriter()))
43 };
44
45 Self {
46 content,
47 current_length: initial_length,
48 timestamp: Instant::now(),
49 line_count: 1,
50 typewriter_cursor,
51 }
52 }
53
54 pub fn calculate_wrapped_line_count(&mut self, viewport: &Viewport) {
55 let clean_content = clean_message_for_display(&self.content);
56 if clean_content.is_empty() {
57 self.line_count = 1;
58 return;
59 }
60
61 let effective_width = (viewport.output_area().width as usize)
62 .saturating_sub(2)
63 .max(10);
64 let raw_lines: Vec<&str> = clean_content.lines().collect();
65
66 let lines_to_process = if clean_content.ends_with('\n') {
67 let mut lines = raw_lines;
68 lines.push("");
69 lines
70 } else if raw_lines.is_empty() {
71 vec![""]
72 } else {
73 raw_lines
74 };
75
76 self.line_count = lines_to_process
77 .iter()
78 .map(|line| {
79 if line.is_empty() {
80 1
81 } else {
82 ((line.graphemes(true).count().saturating_sub(1)) / effective_width) + 1
83 }
84 })
85 .sum::<usize>()
86 .max(1);
87 }
88
89 pub fn is_typing(&self) -> bool {
90 self.typewriter_cursor.is_some()
91 && self.current_length < self.content.graphemes(true).count()
92 }
93 pub fn is_cursor_visible(&self) -> bool {
94 self.typewriter_cursor
95 .as_ref()
96 .is_some_and(|c| c.is_visible())
97 }
98}
99
100pub struct MessageDisplay {
101 messages: Vec<Message>,
102 line_cache: Vec<CachedLine>,
103 cache_dirty: bool,
104 config: Config,
105 viewport: Viewport,
106 persistent_cursor: UiCursor,
107}
108
109impl MessageDisplay {
110 pub fn new(config: &Config, terminal_width: u16, terminal_height: u16) -> Self {
111 Self::log_startup();
112 Self {
113 messages: Vec::with_capacity(config.max_messages),
114 line_cache: Vec::new(),
115 cache_dirty: true,
116 config: config.clone(),
117 viewport: Viewport::new(terminal_width, terminal_height),
118 persistent_cursor: UiCursor::from_config(config, CursorKind::Output),
119 }
120 }
121
122 fn rebuild_line_cache(&mut self) {
123 self.line_cache.clear();
124 let effective_width = (self.viewport.output_area().width as usize)
125 .saturating_sub(2)
126 .max(10);
127
128 for (msg_idx, message) in self.messages.iter().enumerate() {
129 let visible_content = if message.is_typing() {
130 let graphemes: Vec<&str> = message.content.graphemes(true).collect();
131 graphemes
132 .iter()
133 .take(message.current_length)
134 .copied()
135 .collect::<String>()
136 } else {
137 message.content.clone()
138 };
139
140 let clean_content = clean_message_for_display(&visible_content);
141 let lines: Vec<String> = if clean_content.is_empty() {
142 vec![String::new()]
143 } else {
144 let mut lines: Vec<String> = clean_content.lines().map(|s| s.to_string()).collect();
145 if clean_content.ends_with('\n') {
146 lines.push(String::new());
147 }
148 if lines.is_empty() {
149 lines.push(String::new());
150 }
151 lines
152 };
153
154 for (line_idx, raw_line) in lines.iter().enumerate() {
155 if raw_line.is_empty() {
156 self.line_cache.push(CachedLine {
157 content: String::new(),
158 message_index: msg_idx,
159 is_partial: false,
160 visible_chars: 0,
161 });
162 } else {
163 let graphemes: Vec<&str> = raw_line.graphemes(true).collect();
164 let mut start = 0;
165 while start < graphemes.len() {
166 let end = (start + effective_width).min(graphemes.len());
167 let wrapped_line = graphemes[start..end].join("");
168 let is_last_chunk = end == graphemes.len();
169 let is_last_line = line_idx == lines.len() - 1;
170
171 self.line_cache.push(CachedLine {
172 content: wrapped_line.clone(),
173 message_index: msg_idx,
174 is_partial: message.is_typing() && is_last_line && is_last_chunk,
175 visible_chars: wrapped_line.graphemes(true).count(),
176 });
177 start = end;
178 }
179 }
180 }
181 }
182
183 if let Some(last_msg) = self.messages.last() {
184 if !last_msg.is_typing() {
185 self.line_cache.push(CachedLine {
186 content: String::new(),
187 message_index: self.messages.len(),
188 is_partial: false,
189 visible_chars: 0,
190 });
191 }
192 }
193
194 self.cache_dirty = false;
195 self.viewport
196 .update_content_height_silent(self.line_cache.len());
197 }
198
199 pub fn get_visible_messages(&mut self) -> Vec<(String, usize, bool, bool, bool)> {
200 if self.cache_dirty {
201 self.rebuild_line_cache();
202 }
203
204 let window_height = self.viewport.window_height();
205 let scroll_offset = self.viewport.scroll_offset();
206 let available_lines = self.line_cache.len().saturating_sub(scroll_offset);
207 let lines_to_show = available_lines.min(window_height);
208 let visible_start = scroll_offset;
209 let visible_end = scroll_offset + lines_to_show;
210
211 let mut result = Vec::new();
212 if self.line_cache.is_empty() {
213 result.push((
214 String::new(),
215 0,
216 false,
217 false,
218 self.persistent_cursor.is_visible(),
219 ));
220 return result;
221 }
222
223 for line_idx in visible_start..visible_end {
224 if let Some(cached_line) = self.line_cache.get(line_idx) {
225 let msg_idx = cached_line.message_index;
226 let is_last_line = line_idx == self.line_cache.len() - 1;
227
228 let (is_typing, cursor_visible) = if msg_idx < self.messages.len() {
229 self.messages.get(msg_idx).map_or((false, false), |msg| {
230 (
231 cached_line.is_partial && msg.is_typing(),
232 msg.is_cursor_visible() && cached_line.is_partial,
233 )
234 })
235 } else {
236 (false, false)
237 };
238
239 let persistent_cursor =
240 is_last_line && !is_typing && self.persistent_cursor.is_visible();
241 result.push((
242 cached_line.content.clone(),
243 cached_line.visible_chars,
244 is_typing,
245 cursor_visible,
246 persistent_cursor,
247 ));
248 }
249 }
250
251 while result.len() < window_height {
252 result.push((String::new(), 0, false, false, false));
253 }
254 result
255 }
256
257 pub fn add_message(&mut self, content: String) {
258 self.add_message_with_typewriter(content, true);
259 }
260 pub fn add_message_instant(&mut self, content: String) {
261 self.add_message_with_typewriter(content, false);
262 }
263
264 fn add_message_with_typewriter(&mut self, content: String, use_typewriter: bool) {
265 let line_count = content.lines().count();
266 let force_instant = line_count > 5 || content.len() > 200;
267
268 Self::log_to_file(&content);
269
270 if self.messages.len() >= self.config.max_messages {
271 self.messages.remove(0);
272 self.cache_dirty = true;
273 }
274
275 let typewriter_delay = if use_typewriter && !force_instant {
276 self.config.typewriter_delay
277 } else {
278 Duration::from_millis(0)
279 };
280
281 let mut message = Message::new(content, typewriter_delay);
282 message.calculate_wrapped_line_count(&self.viewport);
283 self.messages.push(message);
284 self.cache_dirty = true;
285 self.rebuild_line_cache();
286
287 if self.viewport.is_auto_scroll_enabled() {
288 let content_height = self.line_cache.len();
289 let window_height = self.viewport.window_height();
290 if content_height > window_height {
291 self.viewport
292 .set_scroll_offset_direct_silent(content_height - window_height);
293 }
294 }
295 }
296
297 pub fn update_typewriter(&mut self) {
298 self.persistent_cursor.update_blink();
299 if self.config.typewriter_delay.as_millis() == 0 {
300 return;
301 }
302
303 let mut needs_rebuild = false;
304 if let Some(last_message) = self.messages.last_mut() {
305 let total_length = last_message.content.graphemes(true).count();
306 if let Some(ref mut cursor) = last_message.typewriter_cursor {
307 cursor.update_blink();
308 }
309
310 if last_message.current_length < total_length {
311 let elapsed = last_message.timestamp.elapsed();
312 if elapsed >= self.config.typewriter_delay {
313 let old_length = last_message.current_length;
314 let chars_to_add = if self.config.typewriter_delay.as_millis() <= 5 {
315 ((elapsed.as_millis() as f64
316 / self.config.typewriter_delay.as_millis() as f64)
317 .floor()
318 .max(1.0)) as usize
319 } else {
320 1
321 };
322
323 let new_length = (last_message.current_length + chars_to_add).min(total_length);
324 last_message.current_length = new_length;
325 last_message.timestamp = Instant::now();
326
327 let next_chars = last_message
328 .content
329 .chars()
330 .skip(old_length)
331 .take(chars_to_add)
332 .collect::<String>();
333 if next_chars.contains('\n') || (new_length - old_length) > 50 {
334 needs_rebuild = true;
335 }
336
337 self.cache_dirty = true;
338 if new_length == total_length {
339 last_message.typewriter_cursor = None;
340 needs_rebuild = true;
341 self.viewport.enable_auto_scroll_silent();
342 self.viewport.scroll_to_bottom();
343 }
344 }
345 }
346 }
347 if needs_rebuild && self.cache_dirty {
348 self.rebuild_line_cache();
349 }
350 }
351
352 pub fn handle_scroll(&mut self, direction: ScrollDirection, amount: usize) {
353 match direction {
354 ScrollDirection::Up => self.viewport.scroll_up(amount.max(1)),
355 ScrollDirection::Down => self.viewport.scroll_down(amount.max(1)),
356 ScrollDirection::PageUp => self.viewport.page_up(),
357 ScrollDirection::PageDown => self.viewport.page_down(),
358 ScrollDirection::ToTop => self.viewport.scroll_to_top(),
359 ScrollDirection::ToBottom => self.viewport.scroll_to_bottom(),
360 }
361 }
362
363 pub fn handle_resize(&mut self, width: u16, height: u16) -> bool {
364 let changed = self.viewport.update_terminal_size(width, height);
365 if changed {
366 for message in &mut self.messages {
367 message.calculate_wrapped_line_count(&self.viewport);
368 }
369 self.cache_dirty = true;
370 self.viewport.force_auto_scroll();
371 }
372 changed
373 }
374
375 pub fn clear_messages(&mut self) {
376 self.messages.clear();
377 self.line_cache.clear();
378 self.cache_dirty = false;
379 self.viewport.update_content_height_silent(0);
380 self.viewport.force_auto_scroll();
381 self.persistent_cursor.show_cursor();
382 }
383
384 pub fn create_output_widget_for_rendering(&mut self) -> RenderData<'_> {
385 (
386 self.get_visible_messages(),
387 self.config.clone(),
388 self.viewport.output_area(),
389 &self.persistent_cursor,
390 )
391 }
392
393 pub fn update_config(&mut self, new_config: &Config) {
394 self.config = new_config.clone();
395 self.persistent_cursor = UiCursor::from_config(new_config, CursorKind::Output);
396 self.cache_dirty = true;
397 if self.messages.len() > self.config.max_messages {
398 let excess = self.messages.len() - self.config.max_messages;
399 self.messages.drain(0..excess);
400 self.cache_dirty = true;
401 }
402 }
403
404 pub fn viewport(&self) -> &Viewport {
406 &self.viewport
407 }
408 pub fn viewport_mut(&mut self) -> &mut Viewport {
409 &mut self.viewport
410 }
411 pub fn get_messages_count(&self) -> usize {
412 self.messages.len()
413 }
414 pub fn get_line_count(&self) -> usize {
415 if self.cache_dirty {
416 self.messages.iter().map(|m| m.line_count).sum()
417 } else {
418 self.line_cache.len()
419 }
420 }
421 pub fn get_content_height(&self) -> usize {
422 self.viewport.content_height()
423 }
424 pub fn get_window_height(&self) -> usize {
425 self.viewport.window_height()
426 }
427
428 pub fn debug_scroll_status(&self) -> String {
429 format!(
430 "Scroll: offset={}, lines={}, window={}, auto={}, msgs={}, cache={}",
431 self.viewport.scroll_offset(),
432 self.viewport.content_height(),
433 self.viewport.window_height(),
434 self.viewport.is_auto_scroll_enabled(),
435 self.messages.len(),
436 self.line_cache.len()
437 )
438 }
439
440 pub fn handle_viewport_event(&mut self, event: ViewportEvent) -> bool {
441 let changed = self.viewport.handle_event(event);
442 if changed {
443 for message in &mut self.messages {
444 message.calculate_wrapped_line_count(&self.viewport);
445 }
446 self.cache_dirty = true;
447 }
448 changed
449 }
450
451 pub fn log(&mut self, level: &str, message: &str) {
452 self.add_message(format!("[{}] {}", level, message));
453 }
454
455 fn log_to_file(content: &str) {
456 if content.starts_with("__") || content.trim().is_empty() {
457 return;
458 }
459 if let Ok(exe_path) = std::env::current_exe() {
460 if let Some(base_dir) = exe_path.parent() {
461 let log_path = base_dir.join(".rss").join("rush.logs");
462 let _ = std::fs::create_dir_all(log_path.parent().unwrap());
463 let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S");
464 let log_line = format!("[{}] {}\n", timestamp, content);
465 let _ = std::fs::OpenOptions::new()
466 .create(true)
467 .append(true)
468 .open(&log_path)
469 .and_then(|mut file| {
470 use std::io::Write;
471 file.write_all(log_line.as_bytes())
472 });
473 }
474 }
475 }
476
477 fn log_startup() {
478 if let Ok(exe_path) = std::env::current_exe() {
479 if let Some(base_dir) = exe_path.parent() {
480 let log_path = base_dir.join(".rss").join("rush.logs");
481 let _ = std::fs::create_dir_all(log_path.parent().unwrap());
482 let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S");
483 let version = crate::core::constants::VERSION;
484 let startup_line = format!(
485 "[{}] === Rush Sync Server v{} Started ===\n",
486 timestamp, version
487 );
488 let _ = std::fs::OpenOptions::new()
489 .create(true)
490 .append(true)
491 .open(&log_path)
492 .and_then(|mut file| {
493 use std::io::Write;
494 file.write_all(startup_line.as_bytes())
495 });
496 }
497 }
498 }
499}
500
501fn clean_ansi_codes(message: &str) -> String {
503 String::from_utf8_lossy(&strip(message.as_bytes()).unwrap_or_default()).into_owned()
504}
505
506fn clean_message_for_display(message: &str) -> String {
507 clean_ansi_codes(message)
508 .replace("__CONFIRM_EXIT__", "")
509 .replace("__CLEAR__", "")
510 .trim()
511 .to_string()
512}
513
514fn parse_message_parts(message: &str) -> Vec<(String, bool)> {
515 let mut parts = Vec::new();
516 let mut chars = message.char_indices().peekable();
517 let mut start = 0;
518
519 while let Some((i, c)) = chars.peek().cloned() {
520 if c == '[' {
521 if start < i {
522 let text = &message[start..i];
523 if !text.trim().is_empty() {
524 parts.push((text.to_owned(), false));
525 }
526 }
527 if let Some(end_idx) = message[i..].find(']') {
528 let end = i + end_idx + 1;
529 parts.push((message[i..end].to_owned(), true));
530 start = end;
531 while let Some(&(ci, _)) = chars.peek() {
532 if ci < end {
533 chars.next();
534 } else {
535 break;
536 }
537 }
538 } else {
539 parts.push((message[i..].to_owned(), false));
540 break;
541 }
542 } else {
543 chars.next();
544 }
545 }
546
547 if start < message.len() {
548 let remaining = &message[start..];
549 if !remaining.trim().is_empty() {
550 parts.push((remaining.to_owned(), false));
551 }
552 }
553 if parts.is_empty() {
554 parts.push((message.to_owned(), false));
555 }
556 parts
557}
558
559fn get_marker_color(marker: &str) -> AppColor {
560 let display_text = marker.trim_start_matches('[').trim_end_matches(']');
561 AppColor::from_display_text(display_text) }
563
564pub fn create_output_widget<'a>(
565 messages: &'a [(String, usize, bool, bool, bool)],
566 layout_area: crate::ui::viewport::LayoutArea,
567 config: &'a Config,
568 cursor_state: &'a UiCursor,
569) -> Paragraph<'a> {
570 let max_lines = layout_area.height as usize;
571 if max_lines == 0 || layout_area.width == 0 {
572 return Paragraph::new(vec![Line::from(vec![Span::raw(get_translation(
573 "screen.render.invalid_layout",
574 &[],
575 ))])])
576 .block(
577 Block::default()
578 .borders(Borders::NONE)
579 .style(Style::default().bg(config.theme.output_bg.into())),
580 );
581 }
582
583 let safe_max_lines = max_lines.min(1000);
584 let mut lines = Vec::new();
585
586 if messages.is_empty() {
587 return Paragraph::new(vec![Line::from(vec![Span::raw("")]); safe_max_lines])
588 .block(
589 Block::default()
590 .borders(Borders::NONE)
591 .style(Style::default().bg(config.theme.output_bg.into())),
592 )
593 .wrap(Wrap { trim: true });
594 }
595
596 for (
597 message_idx,
598 (message, current_length, is_typing, msg_cursor_visible, persistent_cursor_visible),
599 ) in messages.iter().enumerate()
600 {
601 let is_last_message = message_idx == messages.len() - 1;
602
603 if message.is_empty() {
604 if *persistent_cursor_visible {
605 lines.push(Line::from(vec![cursor_state.create_cursor_span(config)]));
606 } else {
607 lines.push(Line::from(vec![Span::raw("")]));
608 }
609 continue;
610 }
611
612 let clean_message = clean_message_for_display(message);
613 let message_lines: Vec<&str> = clean_message.lines().collect();
614
615 if message_lines.is_empty() {
616 lines.push(Line::from(vec![Span::raw("")]));
617 } else {
618 for (line_idx, line_content) in message_lines.iter().enumerate() {
619 if lines.len() >= safe_max_lines {
620 break;
621 }
622
623 let is_last_line = line_idx == message_lines.len() - 1;
624 let visible_chars = if is_last_message && is_last_line {
625 let chars_before_this_line: usize = message_lines
626 .iter()
627 .take(line_idx)
628 .map(|l| l.graphemes(true).count() + 1)
629 .sum();
630 current_length
631 .saturating_sub(chars_before_this_line)
632 .min(line_content.graphemes(true).count())
633 } else {
634 line_content.graphemes(true).count()
635 };
636
637 let message_parts = parse_message_parts(line_content);
638 let mut spans = Vec::new();
639 let mut chars_used = 0;
640
641 for (part_text, is_marker) in message_parts {
642 let part_chars = part_text.graphemes(true).count();
643 let part_style = if is_marker {
644 Style::default().fg(get_marker_color(&part_text).into())
645 } else {
646 Style::default().fg(config.theme.output_text.into())
647 };
648
649 if chars_used >= visible_chars {
650 break;
651 }
652 let chars_needed = visible_chars - chars_used;
653 if chars_needed >= part_chars {
654 spans.push(Span::styled(part_text, part_style));
655 chars_used += part_chars;
656 } else {
657 let graphemes: Vec<&str> = part_text.graphemes(true).collect();
658 spans.push(Span::styled(
659 graphemes
660 .iter()
661 .take(chars_needed)
662 .copied()
663 .collect::<String>(),
664 part_style,
665 ));
666 break;
667 }
668 }
669
670 if is_last_message
671 && is_last_line
672 && ((*is_typing && *msg_cursor_visible)
673 || (!*is_typing && *persistent_cursor_visible))
674 {
675 spans.push(cursor_state.create_cursor_span(config));
676 }
677 if spans.is_empty() {
678 spans.push(Span::raw(""));
679 }
680 lines.push(Line::from(spans));
681 }
682 }
683 if lines.len() >= safe_max_lines {
684 break;
685 }
686 }
687
688 while lines.len() < safe_max_lines {
689 lines.push(Line::from(vec![Span::raw("")]));
690 }
691 lines.truncate(safe_max_lines);
692 if lines.is_empty() {
693 lines.push(Line::from(vec![Span::raw(get_translation(
694 "screen.render.empty_buffer_error",
695 &[],
696 ))]));
697 }
698
699 Paragraph::new(lines)
700 .block(
701 Block::default()
702 .borders(Borders::NONE)
703 .style(Style::default().bg(config.theme.output_bg.into())),
704 )
705 .wrap(Wrap { trim: true })
706}