sylveos

sylveos.rs (7802B)

---

 use std::{
     sync::{
         Arc,
         atomic::{AtomicBool, Ordering},
     },
     time::Duration,
 };
 
 use anyhow::Result;
 use crossterm::event::{Event, EventStream, KeyCode};
 use ratatui::{
     DefaultTerminal, Frame,
     buffer::Buffer,
     layout::{Constraint, Layout, Rect},
     style::{Color, Modifier, Style, Stylize},
     symbols::scrollbar,
     text::Line,
     widgets::{
         Block, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState, StatefulWidget, Tabs,
         Widget,
     },
 };
 use tokio::io::{self, AsyncReadExt, AsyncWriteExt, ReadHalf, WriteHalf};
 use tokio_serial::SerialStream;
 use tokio_stream::StreamExt;
 
 pub async fn start(port: SerialStream) -> Result<()> {
     let terminal = ratatui::init();
     let app_result = App::new(port).run(terminal).await;
     ratatui::restore();
     app_result
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum TabIndex {
     Console = 0,
     Journal = 1,
 }
 
 impl TabIndex {
     fn next(self) -> Self {
         match self {
             TabIndex::Console => TabIndex::Journal,
             TabIndex::Journal => TabIndex::Console,
         }
     }
 
     fn previous(self) -> Self {
         match self {
             TabIndex::Console => TabIndex::Journal,
             TabIndex::Journal => TabIndex::Console,
         }
     }
 }
 
 #[derive(Debug)]
 struct App {
     should_quit: bool,
     current_tab: TabIndex,
     disconnected: Arc<AtomicBool>,
     console_widget: ConsoleWidget,
     journal_widget: JournalWidget,
 }
 
 impl App {
     pub fn new(port: SerialStream) -> Self {
         let (read_port, write_port) = io::split(port);
 
         let console_state = Arc::new(std::sync::RwLock::new(ConsoleState::default()));
         let journal_state = Arc::new(std::sync::RwLock::new(LogState::default()));
         let disconnected = Arc::new(AtomicBool::new(false));
 
         let app = Self {
             should_quit: false,
             current_tab: TabIndex::Console,
             console_widget: ConsoleWidget {
                 state: console_state,
                 write_port: Arc::new(tokio::sync::RwLock::new(write_port)),
                 disconnected: disconnected.clone(),
             },
             journal_widget: JournalWidget {
                 state: journal_state,
                 disconnected: disconnected.clone(),
             },
             disconnected: disconnected.clone(),
         };
 
         // Start the message router
         let console_state = app.console_widget.state.clone();
         let journal_state = app.journal_widget.state.clone();
 
         tokio::spawn(Self::route_messages(
             read_port,
             console_state,
             journal_state,
             disconnected.clone(),
         ));
 
         app
     }
 
     async fn route_messages(
         mut read_port: ReadHalf<SerialStream>,
         console_state: Arc<std::sync::RwLock<ConsoleState>>,
         journal_state: Arc<std::sync::RwLock<LogState>>,
         disconnected: Arc<AtomicBool>,
     ) {
         loop {
             match parse_message(&mut read_port).await {
                 Ok(message) => match message {
                     Message::Console(data) => {
                         let mut state = console_state.write().unwrap();
                         state.buffer.extend(data);
                     }
                     Message::Journal(data) => {
                         let mut state = journal_state.write().unwrap();
                         state.buffer.extend(data);
                     }
                     Message::Disconnect => {
                         disconnected.store(true, Ordering::SeqCst);
                         return;
                     }
                 },
                 Err(_) => {
                     disconnected.store(true, Ordering::SeqCst);
                     return;
                 }
             }
         }
     }
 
     pub async fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
         let period = Duration::from_secs_f32(1.0 / 60.0);
         let mut interval = tokio::time::interval(period);
         let mut events = EventStream::new();
 
         while !self.should_quit {
             tokio::select! {
                 _ = interval.tick() => { terminal.draw(|frame| self.render(frame))?; },
                 Some(Ok(event)) = events.next() => self.handle_event(&event).await?,
             }
         }
         Ok(())
     }
 
     fn render(&self, frame: &mut Frame) {
         let layout = Layout::vertical([
             Constraint::Length(1),
             Constraint::Length(1),
             Constraint::Fill(1),
         ]);
         let [title_area, tabs_area, body_area] = frame.area().layout(&layout);
 
         let title = Line::from("SylveOS").centered().bold();
         frame.render_widget(title, title_area);
 
         let tabs = Tabs::new(vec!["Console", "Journal"])
             .select(self.current_tab as usize)
             .style(Style::default().fg(Color::White))
             .highlight_style(
                 Style::default()
                     .fg(Color::Yellow)
                     .add_modifier(Modifier::BOLD),
             )
             .divider(" | ");
         frame.render_widget(tabs, tabs_area);
 
         // Render active tab content
         match self.current_tab {
             TabIndex::Console => frame.render_widget(&self.console_widget, body_area),
             TabIndex::Journal => frame.render_widget(&self.journal_widget, body_area),
         }
     }
 
     async fn handle_event(&mut self, event: &Event) -> Result<()> {
         let disconnected = self.disconnected.load(Ordering::Relaxed);
         if let Some(key) = event.as_key_press_event() {
             match key.code {
                 KeyCode::Esc => self.should_quit = true,
                 KeyCode::Tab => self.current_tab = self.current_tab.next(),
                 KeyCode::BackTab => self.current_tab = self.current_tab.previous(),
                 KeyCode::Down => match self.current_tab {
                     TabIndex::Console => self.console_widget.scroll_down(),
                     TabIndex::Journal => self.journal_widget.scroll_down(),
                 },
                 KeyCode::Up => match self.current_tab {
                     TabIndex::Console => self.console_widget.scroll_up(),
                     TabIndex::Journal => self.journal_widget.scroll_up(),
                 },
                 KeyCode::PageDown => match self.current_tab {
                     TabIndex::Console => self.console_widget.scroll_to_bottom(),
                     TabIndex::Journal => self.journal_widget.scroll_to_bottom(),
                 },
                 KeyCode::Left if self.current_tab == TabIndex::Console && !disconnected => {
                     self.console_widget.move_cursor_left()
                 }
                 KeyCode::Right if self.current_tab == TabIndex::Console && !disconnected => {
                     self.console_widget.move_cursor_right()
                 }
                 KeyCode::Enter if self.current_tab == TabIndex::Console && !disconnected => {
                     self.console_widget.submit().await?
                 }
                 KeyCode::Char(to_insert)
                     if self.current_tab == TabIndex::Console && !disconnected =>
                 {
                     self.console_widget.enter_char(to_insert)
                 }
                 KeyCode::Backspace if self.current_tab == TabIndex::Console && !disconnected => {
                     self.console_widget.delete_char()
                 }
                 _ => {}
             }
         }
 
         Ok(())
     }
 }
 
 #[derive(Debug)]
 enum Message {
     Console(Vec<u8>),
     Journal(Vec<u8>),
     Disconnect,
 }
 
 async fn parse_message(port: &mut ReadHalf<SerialStream>) -> Result<Message> {
     let byte = port.read_u8().await?;
     if byte == 0 {
         return Ok(Message::Disconnect);
     }
 
     Ok(Message::Console(vec![byte]))
 }