path: root/src/canvas/tui_widgets/data_table/sortable.rs

use std::{borrow::Cow, marker::PhantomData};

use concat_string::concat_string;
use itertools::Itertools;
use tui::widgets::Row;

use super::{
    ColumnHeader, ColumnWidthBounds, DataTable, DataTableColumn, DataTableProps, DataTableState,
    DataTableStyling, DataToCell,
};
use crate::utils::gen_util::truncate_to_text;

/// Denotes the sort order.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SortOrder {
    Ascending,
    Descending,
}

impl SortOrder {
    /// Returns the reverse [`SortOrder`].
    pub fn rev(&self) -> SortOrder {
        match self {
            SortOrder::Ascending => SortOrder::Descending,
            SortOrder::Descending => SortOrder::Ascending,
        }
    }
}

impl Default for SortOrder {
    fn default() -> Self {
        Self::Ascending
    }
}

/// Denotes the [`DataTable`] is unsorted.
pub struct Unsortable;

/// Denotes the [`DataTable`] is sorted.
pub struct Sortable {
    /// The currently selected sort index.
    pub sort_index: usize,

    /// The current sorting order.
    pub order: SortOrder,
}

/// The [`SortType`] trait is meant to be used in the typing of a [`DataTable`]
/// to denote whether the table is meant to display/store sorted or unsorted data.
///
/// Note that the trait is [sealed](https://rust-lang.github.io/api-guidelines/future-proofing.html#sealed-traits-protect-against-downstream-implementations-c-sealed),
/// and therefore only [`Unsortable`] and [`Sortable`] can implement it.
pub trait SortType: private::Sealed {
    /// Constructs the table header.
    fn build_header<H, C>(&self, columns: &[C], widths: &[u16]) -> Row<'_>
    where
        H: ColumnHeader,
        C: DataTableColumn<H>,
    {
        Row::new(columns.iter().zip(widths).filter_map(|(c, &width)| {
            if width == 0 {
                None
            } else {
                Some(truncate_to_text(&c.header(), width))
            }
        }))
    }
}

mod private {
    use super::{Sortable, Unsortable};

    pub trait Sealed {}

    impl Sealed for Unsortable {}
    impl Sealed for Sortable {}
}

impl SortType for Unsortable {}

impl SortType for Sortable {
    fn build_header<H, C>(&self, columns: &[C], widths: &[u16]) -> Row<'_>
    where
        H: ColumnHeader,
        C: DataTableColumn<H>,
    {
        const UP_ARROW: &str = "▲";
        const DOWN_ARROW: &str = "▼";

        Row::new(
            columns
                .iter()
                .zip(widths)
                .enumerate()
                .filter_map(|(index, (c, &width))| {
                    if width == 0 {
                        None
                    } else if index == self.sort_index {
                        let arrow = match self.order {
                            SortOrder::Ascending => UP_ARROW,
                            SortOrder::Descending => DOWN_ARROW,
                        };
                        Some(truncate_to_text(&concat_string!(c.header(), arrow), width))
                    } else {
                        Some(truncate_to_text(&c.header(), width))
                    }
                }),
        )
    }
}

pub trait SortsRow {
    type DataType;

    /// Sorts data.
    fn sort_data(&self, data: &mut [Self::DataType], descending: bool);
}

#[derive(Debug, Clone)]
pub struct SortColumn<T> {
    /// The inner column header.
    inner: T,

    /// The default sort order.
    pub default_order: SortOrder,

    /// A restriction on this column's width.
    pub bounds: ColumnWidthBounds,

    /// Marks that this column is currently "hidden", and should *always* be skipped.
    pub is_hidden: bool,
}

impl<D, T> DataTableColumn<T> for SortColumn<T>
where
    T: ColumnHeader + SortsRow<DataType = D>,
{
    #[inline]
    fn inner(&self) -> &T {
        &self.inner
    }

    #[inline]
    fn inner_mut(&mut self) -> &mut T {
        &mut self.inner
    }

    #[inline]
    fn bounds(&self) -> ColumnWidthBounds {
        self.bounds
    }

    #[inline]
    fn bounds_mut(&mut self) -> &mut ColumnWidthBounds {
        &mut self.bounds
    }

    #[inline]
    fn is_hidden(&self) -> bool {
        self.is_hidden
    }

    #[inline]
    fn set_is_hidden(&mut self, is_hidden: bool) {
        self.is_hidden = is_hidden;
    }

    fn header(&self) -> Cow<'static, str> {
        self.inner.header()
    }

    fn header_len(&self) -> usize {
        self.header().len() + 1
    }
}

impl<D, T> SortColumn<T>
where
    T: ColumnHeader + SortsRow<DataType = D>,
{
    /// Creates a new [`SortColumn`] with a width that follows the header width, which has no shortcut and sorts by
    /// default in ascending order ([`SortOrder::Ascending`]).
    pub fn new(inner: T) -> Self {
        Self {
            inner,
            bounds: ColumnWidthBounds::FollowHeader,
            is_hidden: false,
            default_order: SortOrder::default(),
        }
    }

    /// Creates a new [`SortColumn`] with a hard width, which has no shortcut and sorts by default in
    /// ascending order ([`SortOrder::Ascending`]).
    pub fn hard(inner: T, width: u16) -> Self {
        Self {
            inner,
            bounds: ColumnWidthBounds::Hard(width),
            is_hidden: false,
            default_order: SortOrder::default(),
        }
    }

    /// Creates a new [`SortColumn`] with a soft width, which has no shortcut and sorts by default in
    /// ascending order ([`SortOrder::Ascending`]).
    pub fn soft(inner: T, max_percentage: Option<f32>) -> Self {
        Self {
            inner,
            bounds: ColumnWidthBounds::Soft {
                desired: 0,
                max_percentage,
            },
            is_hidden: false,
            default_order: SortOrder::default(),
        }
    }

    /// Sets the default sort order to [`SortOrder::Ascending`].
    pub fn default_ascending(mut self) -> Self {
        self.default_order = SortOrder::Ascending;
        self
    }

    /// Sets the default sort order to [`SortOrder::Descending`].
    pub fn default_descending(mut self) -> Self {
        self.default_order = SortOrder::Descending;
        self
    }

    /// Given a [`SortColumn`] and the sort order, sort a mutable slice of associated data.
    pub fn sort_by(&self, data: &mut [D], order: SortOrder) {
        let descending = matches!(order, SortOrder::Descending);
        self.inner.sort_data(data, descending);
    }
}

pub struct SortDataTableProps {
    pub inner: DataTableProps,
    pub sort_index: usize,
    pub order: SortOrder,
}

/// A type alias for a sortable [`DataTable`].
pub type SortDataTable<DataType, H> = DataTable<DataType, H, Sortable, SortColumn<H>>;

impl<D, H> SortDataTable<D, H>
where
    D: DataToCell<H>,
    H: ColumnHeader + SortsRow<DataType = D>,
{
    pub fn new_sortable<C: Into<Vec<SortColumn<H>>>>(
        columns: C, props: