lx-ls 0.8.0

//! The grid-details view lists several details views side-by-side.

use std::io::{self, Write};

use nu_ansi_term::AnsiStrings;
use term_grid as tg;

use crate::fs::{Dir, File};
use crate::fs::feature::VcsCache;
use crate::fs::feature::xattr::FileAttributes;
use crate::fs::filter::FileFilter;
use crate::output::cell::TextCell;
use crate::output::details::{Options as DetailsOptions, Row as DetailsRow, Render as DetailsRender};
use crate::output::file_name::Options as FileStyle;
use crate::output::grid::Options as GridOptions;
use crate::output::table::{Table, Row as TableRow, Options as TableOptions};
use crate::output::tree::{TreeParams, TreeDepth};
use crate::theme::Theme;


#[derive(PartialEq, Eq, Debug)]
pub struct Options {
    pub grid: GridOptions,
    pub details: DetailsOptions,
    pub row_threshold: RowThreshold,
}

impl Options {
    pub fn to_details_options(&self) -> &DetailsOptions {
        &self.details
    }
}


/// The grid-details view can be configured to revert to just a details view
/// (with one column) if it wouldn't produce enough rows of output.
///
/// Doing this makes the resulting output look a bit better: when listing a
/// small directory of four files in four columns, the files just look spaced
/// out and it's harder to see what's going on. So it can be enabled just for
/// larger directory listings.
#[derive(PartialEq, Eq, Debug, Copy, Clone)]
pub enum RowThreshold {

    /// Only use grid-details view if it would result in at least this many
    /// rows of output.
    MinimumRows(usize),

    /// Use the grid-details view no matter what.
    AlwaysGrid,
}


pub struct Render<'a> {

    /// The directory that's being rendered here.
    /// We need this to know which columns to put in the output.
    pub dir: Option<&'a Dir>,

    /// The files that have been read from the directory. They should all
    /// hold a reference to it.
    pub files: Vec<File<'a>>,

    /// How to colour various pieces of text.
    pub theme: &'a Theme,

    /// How to format filenames.
    pub file_style: &'a FileStyle,

    /// The grid part of the grid-details view.
    pub grid: &'a GridOptions,

    /// The details part of the grid-details view.
    pub details: &'a DetailsOptions,

    /// How to filter files after listing a directory. The files in this
    /// render will already have been filtered and sorted, but any directories
    /// that we recurse into will have to have this applied.
    pub filter: &'a FileFilter,

    /// The minimum number of rows that there need to be before grid-details
    /// mode is activated.
    pub row_threshold: RowThreshold,

    /// Whether we are skipping Git-ignored files.
    pub vcs_ignoring: bool,

    pub vcs: Option<&'a dyn VcsCache>,

    pub console_width: usize,
}

/// A rendered grid ready for display, containing the cell strings and layout
/// metadata needed to construct the final `uutils_term_grid::Grid`.
struct RenderedGrid {
    cells: Vec<String>,
    column_count: usize,
    row_count: usize,
}

impl<'a> Render<'a> {

    /// Create a temporary Details render that gets used for the columns of
    /// the grid-details render that's being generated.
    ///
    /// This includes an empty files vector because the files get added to
    /// the table in *this* file, not in details: we only want to insert every
    /// *n* files into each column's table, not all of them.
    fn details_for_column(&self) -> DetailsRender<'a> {
        DetailsRender {
            dir:           self.dir,
            files:         Vec::new(),
            theme:         self.theme,
            file_style:    self.file_style,
            opts:          self.details,
            recurse:       None,
            filter:        self.filter,
            vcs_ignoring:  self.vcs_ignoring,
            vcs:           self.vcs,
        }
    }

    /// Create a Details render for when this grid-details render doesn't fit
    /// in the terminal (or something has gone wrong) and we have given up, or
    /// when the user asked for a grid-details view but the terminal width is
    /// not available, so we downgrade.
    pub fn give_up(self) -> DetailsRender<'a> {
        DetailsRender {
            dir:           self.dir,
            files:         self.files,
            theme:         self.theme,
            file_style:    self.file_style,
            opts:          self.details,
            recurse:       None,
            filter:        self.filter,
            vcs_ignoring:  self.vcs_ignoring,
            vcs:           self.vcs,
        }
    }

    // This doesn't take an IgnoreCache even though the details one does
    // because grid-details has no tree view.

    pub fn render<W: Write>(mut self, w: &mut W) -> io::Result<()> {
        if let Some(rendered) = self.find_fitting_grid() {
            let direction = if self.grid.across { tg::Direction::LeftToRight }
                                           else { tg::Direction::TopToBottom };

            let grid = tg::Grid::new(rendered.cells, tg::GridOptions {
                direction,
                filling: tg::Filling::Spaces(4),
                width:   self.console_width,
            });

            write!(w, "{grid}")
        }
        else {
            self.give_up().render(w).map(|_| ())
        }
    }

    fn find_fitting_grid(&mut self) -> Option<RenderedGrid> {
        let options = self.details.table.as_ref().expect("Details table options not given!");

        let drender = self.details_for_column();

        let (first_table, _) = self.make_table(options, &drender);

        let rows = self.files.iter()
                       .map(|file| first_table.row_for_file(file, file_has_xattrs(file)))
                       .collect::<Vec<_>>();

        let file_names = self.files.iter()
                             .map(|file| self.file_style.for_file(file, self.theme).paint().promote())
                             .collect::<Vec<_>>();

        let mut last_working = self.make_rendered_grid(1, options, &file_names, rows.clone(), &drender);

        if file_names.len() == 1 {
            return Some(last_working);
        }

        // If we can't fit everything in a grid 100 columns wide, then
        // something has gone seriously awry
        for column_count in 2..100 {
            let rendered = self.make_rendered_grid(column_count, options, &file_names, rows.clone(), &drender);

            let the_grid_fits = rendered_grid_fits(&rendered, self.console_width);

            if the_grid_fits {
                last_working = rendered;
            }

            if !the_grid_fits || column_count == file_names.len() {
                // If we've figured out how many columns can fit in the user's
                // terminal, and it turns out there aren't enough rows to make
                // it worthwhile (according to LX_GRID_ROWS), then just resort
                // to the lines view.
                if let RowThreshold::MinimumRows(thresh) = self.row_threshold
                    && last_working.row_count < thresh {
                        return None;
                    }

                return Some(last_working);
            }
        }

        None
    }

    fn make_table(&mut self, options: &'a TableOptions, drender: &DetailsRender<'_>) -> (Table<'a>, Vec<DetailsRow>) {
        match (self.vcs, self.dir) {
            (Some(g), Some(d))  => if ! g.has_anything_for(&d.path) { self.vcs = None },
            (Some(g), None)     => if ! self.files.iter().any(|f| g.has_anything_for(&f.path)) { self.vcs = None },
            (None,    _)        => {/* Keep Git how it is */},
        }

        let mut table = Table::new(options, self.vcs, self.theme);
        let mut rows = Vec::new();

        if self.details.header {
            let row = table.header_row();
            table.add_widths(&row);
            rows.push(drender.render_header(row));
        }

        (table, rows)
    }

    fn make_rendered_grid(&mut self, column_count: usize, options: &'a TableOptions, file_names: &[TextCell], rows: Vec<TableRow>, drender: &DetailsRender<'_>) -> RenderedGrid {
        let mut tables = Vec::new();
        for _ in 0 .. column_count {
            tables.push(self.make_table(options, drender));
        }

        let mut num_cells = rows.len();
        if self.details.header {
            num_cells += column_count;
        }

        let original_height = divide_rounding_up(rows.len(), column_count);
        let height = divide_rounding_up(num_cells, column_count);

        for (i, (file_name, row)) in file_names.iter().zip(rows.into_iter()).enumerate() {
            let index = if self.grid.across {
                    i % column_count
                }
                else {
                    i / original_height
                };

            let (ref mut table, ref mut rows) = tables[index];
            table.add_widths(&row);
            let details_row = drender.render_file(row, file_name.clone(), TreeParams::new(TreeDepth::root(), false));
            rows.push(details_row);
        }

        let columns = tables
            .into_iter()
            .map(|(table, details_rows)| {
                drender.iterate_with_table(table, details_rows)
                       .collect::<Vec<_>>()
                })
            .collect::<Vec<_>>();

        // Build the cell strings in the order expected by the grid.
        // For LeftToRight (across): iterate rows, then columns within each row.
        // For TopToBottom: iterate columns, then rows within each column.
        let mut cells = Vec::new();

        if self.grid.across {
            for row in 0 .. height {
                for column in &columns {
                    if row < column.len() {
                        cells.push(AnsiStrings(&column[row].contents).to_string());
                    }
                }
            }
        }
        else {
            for column in &columns {
                for cell in column {
                    cells.push(AnsiStrings(&cell.contents).to_string());
                }
            }
        }

        RenderedGrid {
            cells,
            column_count,
            row_count: height,
        }
    }
}


/// Check whether a rendered grid fits within the given console width by
/// computing the maximum visual width per column and summing with spacing.
fn rendered_grid_fits(rendered: &RenderedGrid, console_width: usize) -> bool {
    if rendered.cells.is_empty() {
        return true;
    }

    let mut col_widths = vec![0usize; rendered.column_count];
    for (i, cell) in rendered.cells.iter().enumerate() {
        let col = i % rendered.column_count;
        let w = visual_width(cell);
        if w > col_widths[col] {
            col_widths[col] = w;
        }
    }

    // Total width = sum of column widths + 4 spaces between each pair
    let spacing = if rendered.column_count > 1 { 4 * (rendered.column_count - 1) } else { 0 };
    let total: usize = col_widths.iter().sum::<usize>() + spacing;

    total <= console_width
}


/// Compute the visual width of a string, stripping ANSI escape sequences.
fn visual_width(s: &str) -> usize {
    use unicode_width::UnicodeWidthChar;

    let mut width = 0;
    let mut in_escape = false;

    for c in s.chars() {
        if in_escape {
            if c == 'm' {
                in_escape = false;
            }
            continue;
        }
        if c == '\x1b' {
            in_escape = true;
            continue;
        }
        width += c.width().unwrap_or(0);
    }

    width
}


fn divide_rounding_up(a: usize, b: usize) -> usize {
    let mut result = a / b;

    if !a.is_multiple_of(b) {
        result += 1;
    }

    result
}


fn file_has_xattrs(file: &File<'_>) -> bool {
    match file.path.attributes() {
        Ok(attrs)  => ! attrs.is_empty(),
        Err(_)     => false,
    }
}