todotxt-tui 0.2.0

mod handle_event_trait;
mod ui_event;
mod ui_state;

pub use handle_event_trait::HandleEvent;
pub use ui_event::*;
pub use ui_state::*;

use crate::{
    config::{Config, UiConfig, WidgetBorderType},
    file_worker::{FileWorker, FileWorkerCommands},
    layout::{Layout, Render},
    todo::{autocomplete, ToDo},
    Result,
};
use crossterm::{
    self,
    event::{self, read, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, MouseEvent},
    execute,
    terminal::{
        disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen, SetTitle,
    },
    ExecutableCommand,
};
use std::{
    io,
    sync::mpsc::Sender,
    sync::{Arc, Mutex},
};
use tui::{
    backend::{Backend, CrosstermBackend},
    layout::{Constraint, Direction, Layout as tuiLayout, Rect},
    style::{Color, Style},
    widgets::{Block, Borders, Paragraph},
    Terminal,
};
use tui_input::{backend::crossterm::EventHandler, Input};

/// Enum representing the different modes of the UI.
#[derive(Debug, PartialEq, Eq)]
enum Mode {
    Input,
    Edit,
    Search,
    Normal,
}

/// The struct representing the UI for the application.
pub struct UI {
    input_chunk: Rect,
    tinput: Input,
    layout: Layout,
    mode: Mode,
    data: Arc<Mutex<ToDo>>,
    tx: Sender<FileWorkerCommands>,
    quit: bool,
    active_color: Color,
    config: UiConfig,
    border_type: WidgetBorderType,
}

impl UI {
    /// Creates a new instance of the UI.
    ///
    /// # Arguments
    ///
    /// * `layout` - The initial layout configuration for the UI.
    /// * `data` - Shared data representing the to-do list.
    /// * `tx` - Sender for communicating with the file worker.
    ///
    /// # Returns
    ///
    /// A new `UI` instance.
    pub fn new(
        layout: Layout,
        data: Arc<Mutex<ToDo>>,
        tx: Sender<FileWorkerCommands>,
        config: &Config,
    ) -> UI {
        UI {
            input_chunk: Rect::default(),
            tinput: Input::default(),
            layout,
            mode: Mode::Normal,
            data,
            tx,
            quit: false,
            active_color: *config.styles.active_color,
            config: config.ui_config.clone(),
            border_type: config.widget_base_config.border_type,
        }
    }

    /// Builds a new `UI` instance using the provided configuration.
    ///
    /// # Arguments
    ///
    /// * `config`: A reference to a `Config` struct containing all necessary settings for building the UI.
    ///
    /// # Returns
    ///
    /// * On success, returns an `Ok(UI)` containing the newly built UI.
    /// * On failure, returns an `Err(Result<(), ErrorKind>)`.
    pub fn build(config: &Config) -> Result<UI> {
        let mut todo = ToDo::new(config.todo_config.clone(), config.styles.clone());

        if let Some(path) = &config.ui_config.save_state_path {
            let state = UIState::load(path)?;
            let (_active, todo_state) = (state.active, state.todo_state);
            todo.update_state(todo_state);
        }

        let todo = Arc::new(Mutex::new(todo));
        let file_worker = FileWorker::new(config.file_worker_config.clone(), todo.clone());

        file_worker.load()?;
        let tx = file_worker.run()?;

        let layout = Layout::from_str(&config.ui_config.layout, todo.clone(), config)?;

        Ok(UI::new(layout, todo, tx.clone(), config))
    }

    /// Updates the input chunk of the UI based on the main chunk's dimensions.
    ///
    /// This method recalculates the position and size of the input chunk based on the dimensions
    /// of the main chunk, ensuring proper rendering of the input field.
    ///
    /// # Arguments
    ///
    /// * `main_chunk` - The main chunk's dimensions, typically representing the entire terminal window.
    fn update_chunk(&mut self, main_chunk: Rect) {
        let layout = tuiLayout::default()
            .direction(Direction::Vertical)
            .constraints([Constraint::Length(3), Constraint::Min(1)])
            .split(main_chunk);
        self.input_chunk = layout[0];
        self.layout.update_chunk(layout[1]);
    }

    /// Runs the user interface, handling setup and cleanup of terminal interactions.
    ///
    /// This method enables raw mode, sets up the terminal, and enters the main event loop.
    ///
    /// # Returns
    ///
    /// An `Result` indicating the success of running the user interface.
    pub fn run(&mut self) -> Result<()> {
        fn run_ui(this: &mut UI) -> Result<()> {
            // setup terminal
            enable_raw_mode()?;
            let mut stdout = io::stdout();
            execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;

            let mut backend = CrosstermBackend::new(stdout);
            backend.execute(SetTitle(this.config.window_title.clone()))?;

            let mut terminal = Terminal::new(backend)?;
            terminal.hide_cursor()?;
            this.update_chunk(terminal.size()?);

            this.draw(&mut terminal)?;
            this.main_loop(&mut terminal)?;

            // restore terminal
            disable_raw_mode()?;
            execute!(
                terminal.backend_mut(),
                LeaveAlternateScreen,
                DisableMouseCapture
            )?;
            terminal.show_cursor()?;

            Ok(())
        }

        if let Err(e) = run_ui(self) {
            self.tx.send(FileWorkerCommands::Exit).unwrap();
            Err(e)
        } else {
            Ok(())
        }
    }

    /// Handles the main event loop of the UI.
    ///
    /// # Arguments
    ///
    /// * `terminal` - The TUI Terminal.
    ///
    /// # Returns
    ///
    /// An `Result` indicating the success of the main loop.
    fn main_loop<B: Backend>(&mut self, terminal: &mut Terminal<B>) -> Result<()> {
        let mut versions = self.data.lock().unwrap().get_version().get_version_all();
        loop {
            if event::poll(self.config.list_refresh_rate)? {
                if self.process_event()? {
                    break;
                }
                versions = self.data.lock().unwrap().get_version().get_version_all();
                self.draw(terminal)?;
            } else if !self
                .data
                .lock()
                .unwrap()
                .get_version()
                .is_actual_all(versions)
            {
                versions = self.data.lock().unwrap().get_version().get_version_all();
                self.draw(terminal)?;
            }
        }
        Ok(())
    }

    /// Draws the UI on the terminal.
    ///
    /// # Arguments
    ///
    /// * `terminal` - The TUI Terminal.
    ///
    /// # Returns
    ///
    /// An `Result` indicating the success of drawing.
    fn draw<B: Backend>(&self, terminal: &mut Terminal<B>) -> Result<()> {
        let mut block = Block::default()
            .borders(Borders::ALL)
            .title("Input")
            .border_type(self.border_type.into());
        if self.mode == Mode::Input || self.mode == Mode::Edit || self.mode == Mode::Search {
            block = block.border_style(Style::default().fg(self.active_color));
        }
        terminal.draw(|f| {
            f.render_widget(
                Paragraph::new(self.tinput.value()).block(block),
                self.input_chunk,
            );
            self.layout.render(f);

            if self.mode == Mode::Input || self.mode == Mode::Edit {
                let width = self.input_chunk.width.max(3) - 3;
                let scroll = self.tinput.visual_scroll(width as usize);
                f.set_cursor(
                    self.input_chunk.x
                        + (self.tinput.visual_cursor().max(scroll) - scroll) as u16
                        + 1,
                    self.input_chunk.y + 1,
                );
            }
        })?;
        Ok(())
    }

    /// Handles various user events.
    ///
    /// # Returns
    ///
    /// An `Result` indicating whether the application should exit.
    fn process_event(&mut self) -> Result<bool> {
        self.handle_event_window(read()?);
        Ok(self.quit)
    }

    /// Handles window events, such as resizing and mouse clicks, to manage the
    /// user interface state.
    ///
    /// # Arguments
    ///
    /// * `e`: The event that triggers the function, which can be a resize event
    ///   or a mouse click event.
    ///
    /// # Details
    ///
    /// This function processes different types of events:
    /// - **Resize Event**: Adjusts the UI chunk based on the new window dimensions.
    /// - **Mouse Click Event**: Triggers a click action in the layout manager
    ///   at the specified column and row.
    /// - **Keyboard Events**: Depending on the current mode (`Mode::Input`, `Mode::Edit`,
    ///   or `Mode::Normal`), handles input for task creation, editing, and general navigation
    ///   using specific keys.
    fn handle_event_window(&mut self, e: Event) {
        match e {
            Event::Resize(width, height) => {
                log::debug!("Resize event: width {width}, height {height}");
                self.update_chunk(Rect::new(0, 0, width, height));
            }
            Event::Mouse(MouseEvent {
                kind: event::MouseEventKind::Up(event::MouseButton::Left),
                column,
                row,
                modifiers: _,
            }) => {
                log::debug!("Mouse event: column {column}, row {row}");
                self.layout.click(column, row);
            }
            Event::Key(event) => match self.mode {
                Mode::Input => match event.code {
                    KeyCode::Enter => {
                        if let Err(e) = self.data.lock().unwrap().new_task(self.tinput.value()) {
                            log::error!("Error while adding new task: {e}");
                            // TODO show something on screen
                        }
                        self.tinput.reset();
                        self.mode = Mode::Normal;
                        self.layout.focus();
                    }
                    KeyCode::Esc => {
                        self.mode = Mode::Normal;
                        self.layout.focus();
                    }
                    KeyCode::Tab => {
                        if let Some(input) =
                            autocomplete(&self.data.lock().unwrap(), self.tinput.value())
                        {
                            self.tinput = input.into();
                        }
                    }
                    _ => {
                        self.tinput.handle_event(&e);
                    }
                },
                Mode::Edit => match event.code {
                    KeyCode::Enter => {
                        if let Err(e) = self.data.lock().unwrap().update_active(self.tinput.value())
                        {
                            log::error!("Error while updating existing task: {e}");
                            // TODO show something on screen
                        }
                        self.tinput.reset();
                        self.mode = Mode::Normal;
                        self.layout.focus();
                    }
                    KeyCode::Esc => {
                        self.tinput.reset();
                        self.mode = Mode::Normal;
                        self.layout.focus();
                    }
                    KeyCode::Tab => {
                        if let Some(input) =
                            autocomplete(&self.data.lock().unwrap(), self.tinput.value())
                        {
                            self.tinput = input.into();
                        }
                    }
                    _ => {
                        self.tinput.handle_event(&e);
                    }
                },
                Mode::Search => match event.code {
                    KeyCode::Enter => {
                        self.mode = Mode::Normal;
                        self.layout.focus();
                    }
                    KeyCode::Esc => {
                        self.tinput.reset();
                        self.mode = Mode::Normal;
                        self.layout.clean_search();
                        self.layout.focus();
                    }
                    _ => {
                        self.tinput.handle_event(&e);
                        self.layout.search(self.tinput.to_string())
                    }
                },
                Mode::Normal => {
                    let _ = self.handle_key(&event.code) || self.layout.handle_key(&event);
                }
            },
            _ => {}
        }
    }
}

impl HandleEvent for UI {
    fn get_event(&self, key: &KeyCode) -> UIEvent {
        self.config.window_keybinds.get_event(key)
    }

    fn handle_event(&mut self, event: UIEvent) -> bool {
        use UIEvent::*;
        match event {
            Quit => {
                if let Some(path) = &self.config.save_state_path {
                    if let Err(e) =
                        UIState::new(&self.layout, &self.data.lock().unwrap()).save(path)
                    {
                        log::error!("Error while saveing UI state: {}", e);
                    }
                }
                self.quit = true;
            }
            InsertMode => {
                self.mode = Mode::Input;
                self.layout.unfocus();
            }
            MoveRight => {
                self.layout.right();
            }
            MoveLeft => {
                self.layout.left();
            }
            MoveUp => {
                self.layout.up();
            }
            MoveDown => {
                self.layout.down();
            }
            Save => {
                if let Err(e) = self.tx.send(FileWorkerCommands::ForceSave) {
                    log::error!("Error while send signal to save todo list: {e}");
                    // TODO show something on screen
                }
            }
            Load => {
                if let Err(e) = self.tx.send(FileWorkerCommands::Load) {
                    log::error!("Error while send signal to load todo list: {e}");
                    // TODO show something on screen
                }
            }
            EditMode => {
                if let Some(active) = self.data.lock().unwrap().get_active() {
                    self.tinput = active.to_string().into();
                    self.mode = Mode::Edit;
                    self.layout.unfocus();
                    // self.in
                }
            }
            SearchMode => {
                self.tinput.reset();
                self.mode = Mode::Search;
                self.layout.unfocus();
            }
            _ => {
                return false;
            }
        }
        true
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::Conf;
    use crossterm::event::{KeyEvent, KeyModifiers};
    use std::env;
    use std::error::Error;
    use test_log::test;

    fn default_ui() -> Result<UI> {
        let config = Config::from_reader(
            format!(
                r#"
            todo_path = "{}todo.txt"

            [list_keybind]
            E = "EditMode"
            Enter = "Select"
            I = "InsertMode"
            L = "Load"
            S = "Save"
            j = "ListDown"
            q = "Quit"
            "#,
                env::var("TODO_TUI_TEST_DIR")?
            )
            .as_bytes(),
        )?;
        UI::build(&config)
    }

    #[test]
    fn test_behaviour() -> std::result::Result<(), Box<dyn Error>> {
        let mut ui = default_ui()?;
        ui.update_chunk(Rect::new(0, 0, 20, 20));

        let event = Event::Resize(50, 50);
        ui.handle_event_window(event);

        let event = Event::Key(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE));
        ui.handle_event_window(event);

        let event = Event::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
        ui.handle_event_window(event);
        // assert!(ui.data.lock().unwrap().get_active().is_some());

        // let event = Event::Key(KeyEvent::new(KeyCode::Char('I'), KeyModifiers::NONE));
        // ui.handle_event_window(event);
        // assert_eq!(ui.mode, Mode::Input);
        //
        // let event = Event::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        // ui.handle_event_window(event);
        // assert_eq!(ui.mode, Mode::Normal);
        //
        // let event = Event::Key(KeyEvent::new(KeyCode::Char('E'), KeyModifiers::NONE));
        // ui.handle_event_window(event);
        // assert_eq!(ui.mode, Mode::Edit);
        //
        // let event = Event::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
        // ui.handle_event_window(event);
        // assert_eq!(ui.mode, Mode::Normal);
        //
        // assert!(!ui.quit);
        // let event = Event::Key(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE));
        // ui.handle_event_window(event);
        // assert!(ui.quit);
        // ui.quit = false;
        //
        // let event = Event::Key(KeyEvent::new(KeyCode::Char('S'), KeyModifiers::NONE));
        // ui.handle_event_window(event);
        //
        // let event = Event::Key(KeyEvent::new(KeyCode::Char('L'), KeyModifiers::NONE));
        // ui.handle_event_window(event);

        Ok(())
    }
}