clide/src/tui/app.rs

use crate::tui::component::{Action, Component};
use crate::tui::editor::Editor;
use crate::tui::explorer::Explorer;
use crate::tui::logger::Logger;
use anyhow::{Context, Result, bail};
use log::{debug, error, info, trace, warn};
use ratatui::buffer::Buffer;
use ratatui::crossterm::event;
use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
use ratatui::layout::{Constraint, Direction, Layout, Rect};
use ratatui::prelude::{Color, Style, Widget};
use ratatui::widgets::{Block, Borders, Padding, Tabs};
use ratatui::{DefaultTerminal, symbols};
use std::path::PathBuf;
use std::time::Duration;

// TODO: Need a way to dynamically run Widget::render on all widgets.
// TODO: + Need a way to map Rect to Component::id() to position each widget?
// TODO: Need a way to dynamically run Component methods on all widgets.
pub enum AppComponents<'a> {
    AppEditor(Editor),
    AppExplorer(Explorer<'a>),
    AppLogger(Logger),
    AppComponent(Box<dyn Component>),
}

/// Usage: get_component_mut::<Editor>() OR get_component::<Editor>()
///
/// Implementing this trait for each AppComponent allows for easy lookup in the vector.
pub(crate) trait ComponentOf<T> {
    fn as_ref(&self) -> Option<&T>;
    fn as_mut(&mut self) -> Option<&mut T>;
}

pub struct App<'a> {
    components: Vec<AppComponents<'a>>,
}

impl<'a> App<'a> {
    pub fn new(root_path: PathBuf) -> Result<Self> {
        let mut app = Self {
            components: vec![
                AppComponents::AppExplorer(Explorer::new(&root_path)?),
                AppComponents::AppEditor(Editor::new()),
                AppComponents::AppLogger(Logger::new()),
            ],
        };
        app.get_component_mut::<Editor>()
            .unwrap()
            .set_contents(&root_path.join("src/tui/app.rs"))
            .context(format!(
                "Failed to initialize editor contents to path: {root_path:?}"
            ))?;
        Ok(app)
    }

    fn get_component<T>(&self) -> Option<&T>
    where
        AppComponents<'a>: ComponentOf<T>,
    {
        self.components.iter().find_map(|c| c.as_ref())
    }

    fn get_component_mut<T>(&mut self) -> Option<&mut T>
    where
        AppComponents<'a>: ComponentOf<T>,
    {
        self.components.iter_mut().find_map(|c| c.as_mut())
    }

    pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
        loop {
            self.refresh_editor_contents()
                .context("Failed to refresh editor contents.")?;

            terminal.draw(|f| {
                f.render_widget(&mut self, f.area());
            })?;

            // TODO: Handle events based on which component is active.
            if event::poll(Duration::from_millis(250)).context("event poll failed")? {
                match self.handle_event(event::read()?)? {
                    Action::Quit => break,
                    Action::Handled => {}
                    _ => {
                        // bail!("Unhandled event: {:?}", event);
                    }
                }
            }
        }
        Ok(())
    }

    fn draw_status(&self, area: Rect, buf: &mut Buffer) {
        // TODO: Status bar should have drop down menus
        Tabs::new(["File", "Edit", "View", "Help"])
            .style(Style::default())
            .block(Block::default().borders(Borders::ALL))
            .render(area, buf);
    }

    fn draw_tabs(&self, area: Rect, buf: &mut Buffer) {
        // Determine the tab title from the current file (or use a fallback).
        let mut title: Option<&str> = None;
        if let Some(editor) = self.get_component::<Editor>() {
            title = editor
                .file_path
                .as_ref()
                .and_then(|p| p.file_name())
                .and_then(|s| s.to_str())
        }

        Tabs::new(vec![title.unwrap_or("Unknown")])
            .divider(symbols::DOT)
            .block(
                Block::default()
                    .borders(Borders::NONE)
                    .padding(Padding::new(0, 0, 0, 0)),
            )
            .highlight_style(Style::default().fg(Color::LightRed))
            .render(area, buf);
    }

    /// Refresh the contents of the editor to match the selected TreeItem in the file Explorer.
    /// If the selected item is not a file, this does nothing.
    fn refresh_editor_contents(&mut self) -> Result<()> {
        // Use the currently selected TreeItem or get an absolute path to this source file.
        let selected_pathbuf = match self.get_component::<Explorer>().unwrap().selected() {
            Ok(path) => PathBuf::from(path),
            Err(_) => PathBuf::from(std::path::absolute(file!())?.to_string_lossy().to_string()),
        };
        let editor = self
            .get_component_mut::<Editor>()
            .context("Failed to get active editor while refreshing contents.")?;
        if let Some(current_file_path) = editor.file_path.clone() {
            if selected_pathbuf == current_file_path || !selected_pathbuf.is_file() {
                return Ok(());
            }
            return editor.set_contents(&selected_pathbuf);
        }
        bail!("Failed to refresh editor contents")
    }
}

// TODO: Separate complex components into their own widgets.
impl<'a> Widget for &mut App<'a> {
    fn render(self, area: Rect, buf: &mut Buffer)
    where
        Self: Sized,
    {
        let vertical = Layout::default()
            .direction(Direction::Vertical)
            .constraints([
                Constraint::Length(3),      // status bar
                Constraint::Percentage(70), // horizontal layout
                Constraint::Percentage(30), // terminal
            ])
            .split(area);

        let horizontal = Layout::default()
            .direction(Direction::Horizontal)
            .constraints([
                Constraint::Max(30), // File explorer with a max width of 30 characters.
                Constraint::Fill(1), // Editor fills the remaining space.
            ])
            .split(vertical[1]);

        let editor_layout = Layout::default()
            .direction(Direction::Vertical)
            .constraints([
                Constraint::Length(1), // Editor tabs.
                Constraint::Fill(1),   // Editor contents.
            ])
            .split(horizontal[1]);

        self.draw_status(vertical[0], buf);
        self.draw_tabs(editor_layout[0], buf);
        let id = self.id().to_string();
        for component in &mut self.components {
            match component {
                AppComponents::AppEditor(editor) => editor.render(editor_layout[1], buf),
                AppComponents::AppExplorer(explorer) => {
                    explorer
                        .render(horizontal[0], buf)
                        .context("Failed to render Explorer")
                        .unwrap_or_else(|e| error!(target:id.as_str(), "{}", e));
                }
                AppComponents::AppLogger(logger) => logger.render(vertical[2], buf),
                AppComponents::AppComponent(_) => {}
            }
        }
    }
}

impl<'a> Component for App<'a> {
    fn id(&self) -> &str {
        "App"
    }

    /// TODO: Get active widget with some Component trait function helper?
    /// trait Component { fn get_state() -> ComponentState; }
    /// if component.get_state() = ComponentState::Active { component.handle_event(); }
    ///
    /// App could then provide helpers for altering Component state based on TUI grouping..
    ///    (such as editor tabs, file explorer, status bars, etc..)
    ///
    /// Handles events for the App and delegates to attached Components.
    fn handle_event(&mut self, event: Event) -> Result<Action> {
        // Handle events in the primary application.
        if let Some(key_event) = event.as_key_event() {
            let res = self
                .handle_key_events(key_event)
                .context("Failed to handle key events for primary App Component.");
            match res {
                Ok(Action::Quit) | Ok(Action::Handled) => return res,
                _ => {}
            }
        }

        // Handle events for all components.
        for component in &mut self.components {
            let action = match component {
                AppComponents::AppEditor(editor) => editor.handle_event(event.clone())?,
                AppComponents::AppExplorer(explorer) => explorer.handle_event(event.clone())?,
                AppComponents::AppComponent(comp) => comp.handle_event(event.clone())?,
                AppComponents::AppLogger(logger) => logger.handle_event(event.clone())?,
            };
            // Actions returned here abort the input handling iteration.
            match action {
                Action::Quit | Action::Handled => return Ok(action),
                _ => {}
            }
        }
        Ok(Action::Noop)
    }

    /// Handles key events for the App Component only.
    fn handle_key_events(&mut self, key: KeyEvent) -> Result<Action> {
        match key {
            KeyEvent {
                code: KeyCode::Char('l'),
                modifiers: KeyModifiers::CONTROL,
                kind: KeyEventKind::Press,
                state: _state,
            } => {
                // Some example logs for testing.
                error!(target:self.id(), "an error");
                warn!(target:self.id(), "a warning");
                info!(target:self.id(), "a two line info\nsecond line");
                debug!(target:self.id(), "a debug");
                trace!(target:self.id(), "a trace");
                Ok(Action::Noop)
            }
            KeyEvent {
                code: KeyCode::Char('c'),
                modifiers: KeyModifiers::CONTROL,
                kind: KeyEventKind::Press,
                state: _state,
            } => Ok(Action::Quit),
            _ => Ok(Action::Noop),
        }
    }
}