path: root/hackernews_tui/src/view/comment_view.rs

use super::{article_view, async_view, help_view::HasHelpView, text_view, traits::*, utils};
use crate::prelude::*;
use crate::view::text_view::{StyledPaddingChar, TextPadding};

type SingleItemView = HideableView<PaddedView<text_view::TextView>>;

/// CommentView is a View displaying a list of comments in a HN story
pub struct CommentView {
    view: ScrollView<LinearLayout>,
    items: Vec<HnItem>,
    data: PageData,

    raw_command: String,
}

pub enum NavigationDirection {
    Next,
    Previous,
}

impl ViewWrapper for CommentView {
    wrap_impl!(self.view: ScrollView<LinearLayout>);
}

impl CommentView {
    pub fn new(data: PageData) -> Self {
        let mut view = CommentView {
            view: LinearLayout::vertical()
                .child(HideableView::new(PaddedView::lrtb(
                    1,
                    1,
                    0,
                    1,
                    text_view::TextView::new(
                        data.root_item.text(
                            data.vote_state
                                .get(&data.root_item.id.to_string())
                                .map(|v| v.upvoted),
                        ),
                    ),
                )))
                .scrollable(),
            items: vec![data.root_item.clone()],
            raw_command: String::new(),
            data,
        };

        view.try_update_comments();
        view
    }

    /// Check the comment receiver channel if there are new comments loaded
    /// then update the internal comment data accordingly.
    pub fn try_update_comments(&mut self) {
        let mut new_comments = vec![];
        // limit the number of top comments updated each time
        let mut limit = 5;
        while !self.data.comment_receiver.is_empty() && limit > 0 {
            if let Ok(mut comments) = self.data.comment_receiver.try_recv() {
                new_comments.append(&mut comments);
            }
            limit -= 1;
        }

        if new_comments.is_empty() {
            return;
        }

        let mut new_items = new_comments
            .into_iter()
            .map(Into::<HnItem>::into)
            .collect::<Vec<_>>();

        new_items.iter().for_each(|item| {
            let text_view = text_view::TextView::new(item.text(self.get_vote_status(item.id)));
            self.add_item(HideableView::new(PaddedView::lrtb(
                item.level * 2 + 1,
                1,
                0,
                1,
                if item.level > 0 {
                    // get the padding style (color) based on the comment's height
                    //
                    // We use base 16 colors to display the comment's padding
                    let c = config::Color::from((item.level % 16) as u8);
                    text_view
                        .padding(TextPadding::default().left(StyledPaddingChar::new('▎', c.into())))
                } else {
                    // add top padding for top comments, use the first color in the 16 base colors
                    let c = config::Color::from(0);
                    text_view
                        .padding(TextPadding::default().top(StyledPaddingChar::new('▔', c.into())))
                },
            )));
        });
        self.items.append(&mut new_items);

        // update the view's layout
        self.layout(
            self.get_inner_scroll_view()
                .get_scroller()
                .last_outer_size(),
        )
    }

    /// Return the id of the first item (`direction` dependent),
    /// whose level is less than or equal `max_level`.
    pub fn find_item_id_by_max_level(
        &self,
        start_id: usize,
        max_level: usize,
        direction: NavigationDirection,
    ) -> usize {
        match direction {
            NavigationDirection::Next => (start_id + 1..self.len())
                .find(|&id| self.items[id].level <= max_level)
                .unwrap_or_else(|| self.len()),
            NavigationDirection::Previous => (0..start_id)
                .rfind(|&id| self.items[id].level <= max_level)
                .unwrap_or(start_id),
        }
    }

    /// Return the id of the next visible item (`direction` dependent)
    pub fn find_next_visible_item(&self, start_id: usize, direction: NavigationDirection) -> usize {
        match direction {
            NavigationDirection::Next => (start_id + 1..self.len())
                .find(|&id| self.get_item_view(id).is_visible())
                .unwrap_or_else(|| self.len()),
            NavigationDirection::Previous => (0..start_id)
                .rfind(|&id| self.get_item_view(id).is_visible())
                .unwrap_or(start_id),
        }
    }

    fn get_vote_status(&self, item_id: u32) -> Option<bool> {
        self.data
            .vote_state
            .get(&item_id.to_string())
            .map(|v| v.upvoted)
    }

    fn get_item_view(&self, id: usize) -> &SingleItemView {
        self.get_item(id)
            .unwrap()
            .downcast_ref::<SingleItemView>()
            .unwrap()
    }

    fn get_item_view_mut(&mut self, id: usize) -> &mut SingleItemView {
        self.get_item_mut(id)
            .unwrap()
            .downcast_mut::<SingleItemView>()
            .unwrap()
    }

    /// Toggle the collapsing state of items whose levels are greater than the `min_level`.
    fn toggle_items_collapse_state(&mut self, start_id: usize, min_level: usize) {
        // This function will be called recursively until it's unable to find any items.
        //
        // Note: collapsed item's state is unchanged, we only toggle its visibility.
        // Also, the state and visibility of such item's children are unaffected as they should already
        // be in a hidden state (as result of that item's collapsed state).
        if start_id == self.len() || self.items[start_id].level <= min_level {
            return;
        }
        match self.items[start_id].display_state {
            DisplayState::Hidden => {
                self.items[start_id].display_state = DisplayState::Normal;
                self.get_item_view_mut(start_id).unhide();
                self.toggle_items_collapse_state(start_id + 1, min_level)
            }
            DisplayState::Normal => {
                self.items[start_id].display_state = DisplayState::Hidden;
                self.get_item_view_mut(start_id).hide();
                self.toggle_items_collapse_state(start_id + 1, min_level)
            }
            DisplayState::Minimized => {
                let component = self.get_item_view_mut(start_id);
                if component.is_visible() {
                    component.hide();
                } else {
                    component.unhide();
                }

                // skip toggling all children of the current item
                let next_id = self.find_item_id_by_max_level(
                    start_id,
                    self.items[start_id].level,
                    NavigationDirection::Next,
                );
                self.toggle_items_collapse_state(next_id, min_level)
            }
        };
    }

    /// Toggle the collapsing state of currently focused item and its children
    pub fn toggle_collapse_focused_item(&mut self) {
        let id = self.get_focus_index();
        match self.items[id].display_state {
            DisplayState::Hidden => {
                panic!(
                    "invalid collapse state `Collapsed` when calling `toggle_collapse_focused_item`"
                );
            }
            DisplayState::Minimized => {
                self.toggle_items_collapse_state(id + 1, self.items[id].level);
                self.items[id].display_state = DisplayState::Normal;
            }
            DisplayState::Normal => {
                self.toggle_items_collapse_state(id + 1, self.items[id].level);
                self.items[id].display_state = DisplayState::Minimized;
            }
        };
        self.update_item_text_content(id);
    }

    /// Update the `id`-th item's text content based on its state-based text
    pub fn update_item_text_content(&mut self, id: usize) {
        let new_content =