path: root/src/interactive/app/handlers.rs

use crate::interactive::widgets::MarkMode;
use crate::interactive::{
    app::{FocussedPane::*, TerminalApp},
    path_of, sorted_entries,
    widgets::{HelpPane, MarkPane},
};
use dua::traverse::TreeIndex;
use itertools::Itertools;
use petgraph::{visit::Bfs, Direction};
use std::{fs, io, path::PathBuf};
use termion::event::Key;
use tui::backend::Backend;
use tui_react::Terminal;

pub enum CursorDirection {
    PageDown,
    Down,
    Up,
    PageUp,
}

impl CursorDirection {
    pub fn move_cursor(&self, n: usize) -> usize {
        use CursorDirection::*;
        match self {
            Down => n.saturating_add(1),
            Up => n.saturating_sub(1),
            PageDown => n.saturating_add(10),
            PageUp => n.saturating_sub(10),
        }
    }
}

impl TerminalApp {
    pub fn cycle_focus(&mut self) {
        if let Some(p) = self.window.mark_pane.as_mut() {
            p.set_focus(false)
        };
        self.state.focussed = match (
            self.state.focussed,
            &self.window.help_pane,
            &mut self.window.mark_pane,
        ) {
            (Main, Some(_), _) => Help,
            (Help, _, Some(ref mut pane)) => {
                pane.set_focus(true);
                Mark
            }
            (Help, _, None) => Main,
            (Mark, _, _) => Main,
            (Main, None, None) => Main,
            (Main, None, Some(ref mut pane)) => {
                pane.set_focus(true);
                Mark
            }
        };
    }

    pub fn toggle_help_pane(&mut self) {
        self.state.focussed = match self.state.focussed {
            Main | Mark => {
                self.window.help_pane = Some(HelpPane::default());
                Help
            }
            Help => {
                self.window.help_pane = None;
                Main
            }
        }
    }

    pub fn update_message(&mut self) {
        self.state.message = None;
    }

    pub fn open_that(&mut self) {
        if let Some(ref idx) = self.state.selected {
            open::that(path_of(&self.traversal.tree, *idx)).ok();
        }
    }

    pub fn exit_node(&mut self) {
        match self
            .traversal
            .tree
            .neighbors_directed(self.state.root, Direction::Incoming)
            .next()
        {
            Some(parent_idx) => {
                self.state.root = parent_idx;
                self.state.entries =
                    sorted_entries(&self.traversal.tree, parent_idx, self.state.sorting);
                self.state.selected = self
                    .state
                    .bookmarks
                    .get(&parent_idx)
                    .map(|v| *v)
                    .or_else(|| self.state.entries.get(0).map(|b| b.index));
            }
            None => self.state.message = Some("Top level reached".into()),
        }
    }

    pub fn enter_node(&mut self) {
        if let Some(previously_selected) = self.state.selected {
            let new_entries = sorted_entries(
                &self.traversal.tree,
                previously_selected,
                self.state.sorting,
            );
            match new_entries.get(
                self.state
                    .bookmarks
                    .get(&previously_selected)
                    .and_then(|selected| {
                        new_entries
                            .iter()
                            .find_position(|b| b.index == *selected)
                            .map(|(pos, _)| pos)
                    })
                    .unwrap_or(0),
            ) {
                Some(b) => {
                    self.state
                        .bookmarks
                        .insert(self.state.root, previously_selected);
                    self.state.root = previously_selected;
                    self.state.selected = Some(b.index);
                    self.state.entries = new_entries;
                }
                None => self.state.message = Some("Entry is a file or an empty directory".into()),
            }
        }
    }

    pub fn change_entry_selection(&mut self, direction: CursorDirection) {
        let entries = &self.state.entries;
        let next_selected_pos = match self.state.selected {
            Some(ref selected) => entries
                .iter()
                .find_position(|b| b.index == *selected)
                .map(|(idx, _)| direction.move_cursor(idx))
                .unwrap_or(0),
            None => 0,
        };
        self.state.selected = entries
            .get(next_selected_pos)
            .or_else(|| entries.last())
            .map(|b| b.index)
            .or(self.state.selected);
        if let Some(selected) = self.state.selected {
            self.state.bookmarks.insert(self.state.root, selected);
        }
    }

    pub fn cycle_sorting(&mut self) {
        self.state.sorting.toggle_size();
        self.state.entries =
            sorted_entries(&self.traversal.tree, self.state.root, self.state.sorting);
    }

    pub fn mark_entry(&mut self, advance_cursor: bool) {
        match (self.state.selected, self.window.mark_pane.take()) {
            (Some(index), Some(pane)) => {
                self.window.mark_pane = pane.toggle_index(index, &self.traversal.tree);
            }
            (Some(index), None) => {
                self.window.mark_pane =
                    MarkPane::default().toggle_index(index, &self.traversal.tree)
            }
            _ => {}
        };
        if advance_cursor {
            self.change_entry_selection(CursorDirection::Down)
        }
    }

    fn set_root(&mut self, root: TreeIndex) {
        self.state.root = root;
        self.state.entries = sorted_entries(&self.traversal.tree, root, self.state.sorting);
    }

    pub fn delete_entry(&mut self, index: TreeIndex) -> Result<usize, usize> {
        let mut entries_deleted = 0;
        if let Some(_entry) = self.traversal.tree.node_weight(index) {
            let path_to_delete = path_of(&self.traversal.tree, index);
            delete_directory_recursively(path_to_delete)?;
            let parent_idx = self
                .traversal
                .tree
                .neighbors_directed(index, Direction::Incoming)
                .next()
                .expect("us being unable to delete the root index");
            let mut bfs = Bfs::new(&self.traversal.tree, index);
            while let Some(nx) = bfs.next(&self.traversal.tree) {
                self.traversal.tree.remove_node(nx);
                self.traversal.entries_traversed -= 1;
                entries_deleted += 1;
            }
            self.state.entries =
                sorted_entries(&self.traversal.tree