path: root/src/display.rs

use std::cmp::min;
use std::sync::Arc;

use log::info;
use sysinfo::{DiskExt, System, SystemExt};
use tuikit::attr::*;
use tuikit::term::Term;

use crate::config::Colors;
use crate::content_window::ContentWindow;
use crate::fileinfo::{fileinfo_attr, human_size};
use crate::fm_error::{FmError, FmResult};
use crate::git::git;
use crate::last_edition::LastEdition;
use crate::mode::{MarkAction, Mode};
use crate::preview::Preview;
use crate::status::Status;
use crate::tab::Tab;

/// Is responsible for displaying content in the terminal.
/// It uses an already created terminal.
pub struct Display {
    /// The Tuikit terminal attached to the display.
    /// It will print every symbol shown on screen.
    pub term: Arc<Term>,
    colors: Colors,
    /// system info
    sys: System,
}

impl Display {
    /// Returns a new `Display` instance from a `tuikit::term::Term` object.
    pub fn new(term: Arc<Term>, colors: Colors) -> Self {
        Self {
            term,
            colors,
            sys: System::new_all(),
        }
    }

    const EDIT_BOX_OFFSET: usize = 10;
    const SORT_CURSOR_OFFSET: usize = 36;
    const ATTR_LINE_NR: Attr = Attr {
        fg: Color::CYAN,
        bg: Color::Default,
        effect: Effect::empty(),
    };
    const ATTR_YELLOW: Attr = Attr {
        fg: Color::YELLOW,
        bg: Color::Default,
        effect: Effect::empty(),
    };
    /// Display every possible content in the terminal.
    ///
    /// The top line
    ///
    /// The files if we're displaying them
    ///
    /// The cursor if a content is editable
    ///
    /// The help if `Mode::Help`
    ///
    /// The jump_list if `Mode::Jump`
    ///
    /// The completion list if any.
    ///
    /// The preview in preview mode.
    pub fn display_all(&mut self, status: &Status) -> FmResult<()> {
        // let status = status.selected_non_mut();
        match status.selected_non_mut().mode {
            // Mode::Help => self.help(),
            Mode::Jump => self.jump_list(status),
            Mode::History => self.history(status),
            Mode::Exec | Mode::Goto | Mode::Search => self.completion(status),
            Mode::NeedConfirmation => self.confirmation(status),
            Mode::Preview | Mode::Help => self.preview(status),
            Mode::Shortcut => self.shortcuts(status),
            Mode::Marks(MarkAction::New) | Mode::Marks(MarkAction::Jump) => self.marks(status),
            _ => self.files(status),
        }?;
        self.cursor(status)?;
        self.first_line(status)
    }

    /// Reads and returns the `tuikit::term::Term` height.
    pub fn height(&self) -> FmResult<usize> {
        let (_, height) = self.term.term_size()?;
        Ok(height)
    }

    /// Display the top line on terminal.
    /// Its content depends on the mode.
    /// In normal mode we display the path and number of files.
    /// When a confirmation is needed we ask the user to input `'y'` or
    /// something else.
    fn first_line(&mut self, status: &Status) -> FmResult<()> {
        let tab = status.selected_non_mut();
        let first_row: String = match tab.mode {
            Mode::Normal => {
                format!(
                    "Tab: {}/{}  --  Path: {}   --   Files: {} -- Sum: {} -- Avail: {}  -- {}",
                    status.index + 1,
                    status.len(),
                    tab.path_content.path_to_str()?,
                    tab.path_content.files.len(),
                    human_size(tab.path_content.used_space),
                    human_size(self.disk_space(tab.path_str().unwrap())),
                    git(&tab.path_content.path)?,
                )
            }
            Mode::NeedConfirmation => {
                format!("Confirm {} (y/n) : ", tab.last_edition)
            }
            Mode::Preview => match tab.path_content.selected_file() {
                Some(fileinfo) => {
                    format!("{:?} {}", tab.mode.clone(), fileinfo.path.to_string_lossy())
                }
                None => "".to_owned(),
            },
            Mode::Help => "fm: a dired like file manager. Default keybindings.".to_owned(),
            Mode::Marks(MarkAction::Jump) => "Jump to...".to_owned(),
            Mode::Marks(MarkAction::New) => "Save mark...".to_owned(),
            _ => {
                format!("{:?} {}", tab.mode.clone(), tab.input.string.clone())
            }
        };
        self.term
            .print_with_attr(0, 0, &first_row, Self::ATTR_LINE_NR)?;
        Ok(())
    }

    /// Displays the current directory content, one line per item like in
    /// `ls -l`.
    ///
    /// Those files are always shown, which make it a little bit faster in;
    /// normal (ie. default) mode.
    /// When there's too much files, only those around the selected one are
    /// displayed.
    fn files(&mut self, status: &Status) -> FmResult<()> {
        let tab = status.selected_non_mut();
        let len = tab.path_content.files.len();
        for (i, (file, string)) in std::iter::zip(
            tab.path_content.files.iter(),
            tab.path_content.strings().iter(),
        )
        .enumerate()
        .take(min(len, tab.window.bottom + 1))
        .skip(tab.window.top)
        {
            let row = i + ContentWindow::WINDOW_MARGIN_TOP - tab.window.top;
            let mut attr = fileinfo_attr(status, file, &self.colors);
            if status.flagged.contains(&file.path) {
                attr.effect |= Effect::BOLD | Effect::UNDERLINE;
            }
            self.term.print_with_attr(row, 0, string, attr)?;
        }
        Ok(())
    }

    /// Display a cursor in the top row, at a correct column.
    fn cursor(&mut self, status: &Status) -> FmResult<()> {
        let tab = status.selected_non_mut();
        match tab.mode {
            Mode::Normal | Mode::Help | Mode::Marks(_) => {
                self.term.show_cursor(false)?;
            }
            Mode::NeedConfirmation => {
                self.term.set_cursor(0, tab.last_edition.offset())?;
            }
            Mode::Sort => {
                self.term.set_cursor(0, Self::SORT_CURSOR_OFFSET)?;
            }
            _ => {
                self.term
                    .set_cursor(0, tab.input.cursor_index + Self::EDIT_BOX_OFFSET)?;
            }
        }
        Ok(())
    }

    /// Display the possible jump destination from flagged files.
    fn jump_list(&mut self, tabs: &Status) -> FmResult<()> {
        self.term.clear()?;
        self.term.print(0, 0, "Jump to...")?;
        for (row, path) in tabs.flagged.iter().enumerate