ratatrix/src/components/backlog.rs

/*
 * Copyright (C) 2023  Valentin Lorentz
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License version 3,
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

use std::ops::DerefMut;

use color_eyre::eyre::{Result, WrapErr};
use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
use ratatui::{prelude::*, widgets::*};

use crate::components::Action;
use crate::widgets::prerender::{PrerenderInner, PrerenderValue};
use crate::widgets::{BottomAlignedParagraph, OverlappableWidget};

use super::Component;

#[derive(Default)]
pub struct Backlog {
  scroll: u64,
}

impl Component for Backlog {
  fn handle_key_events(&mut self, key: KeyEvent) -> Result<Option<Action>> {
    match key {
      KeyEvent {
        code: KeyCode::PageUp,
        modifiers: KeyModifiers::NONE,
        kind: KeyEventKind::Press,
        state: _,
      } => {
        self.scroll += 20; // TODO: use the component height
      },
      KeyEvent {
        code: KeyCode::PageDown,
        modifiers: KeyModifiers::NONE,
        kind: KeyEventKind::Press,
        state: _,
      } => {
        self.scroll = self.scroll.saturating_sub(20); // TODO: use the component height
      },
      _ => {},
    }

    Ok(None)
  }

  fn draw(
    &mut self,
    frame: &mut Frame<'_>,
    area: Rect,
    buffers: &crate::buffers::Buffers,
  ) -> Result<()> {
    let block = Block::new().borders(Borders::ALL);
    let mut text_area = block.inner(area);
    block.render(area, frame.buffer_mut());

    let active_buffer = buffers.active_buffer();
    let mut items = active_buffer.content();
    let mut scroll = self.scroll;

    // Skip widgets at the bottom (if scrolled up), and render the first visible one
    loop {
      let Some(item) = items.next() else {
        break;
      };
      let expected_height = match item.prerender.0.lock().unwrap().deref_mut() {
        Some(PrerenderInner {
          key,
          value: PrerenderValue::Rendered(buf),
        }) if *key == text_area.width => buf.area().height as u64,
        Some(PrerenderInner {
          key,
          value: PrerenderValue::NotRendered(height),
        }) if *key == text_area.width => *height,
        prerender => {
          let widget = BottomAlignedParagraph::new(item.text.clone());
          let expected_height = widget.height(text_area.width);
          *prerender = Some(PrerenderInner {
            key: text_area.width,
            value: PrerenderValue::NotRendered(expected_height),
          });
          expected_height
        },
      };

      if scroll.saturating_sub(expected_height) > text_area.height.into() {
        // Paragraph is too far down, not displayed
        scroll -= expected_height;
        continue;
      }

      // TODO: cache this
      let widget = BottomAlignedParagraph::new(item.text).scroll(scroll);
      let height = widget.render_overlap(text_area, frame.buffer_mut());
      text_area.height = text_area.height.saturating_sub(height);

      scroll = scroll.saturating_sub(expected_height);
      if scroll == 0 {
        break;
      }
    }
    if text_area.height == 0 {
      // No more room to display other paragraphs, stop now
      return Ok(());
    }

    // Render other widgets
    for item in items {
      let height = match item.prerender.0.lock().unwrap().deref_mut() {
        Some(PrerenderInner {
          key,
          value: PrerenderValue::Rendered(buf),
        }) if *key == text_area.width => {
          // We already rendered it, copy the buffer.
          assert_eq!(buf.area().width, text_area.width);
          for (y, line) in buf
            .content()
            .chunks(u16::min(buf.area().width, text_area.width) as usize)
            .enumerate()
            .skip(buf.area().height.saturating_sub(text_area.height) as usize)
          {
            for (x, cell) in line.into_iter().enumerate() {
              *frame.buffer_mut().get_mut(
                text_area.x + (x as u16),
                text_area.y + text_area.height + (y as u16) - buf.area().height,
              ) = cell.clone();
            }
          }

          buf.area().height
        },
        prerender => {
          let widget = BottomAlignedParagraph::new(item.text);
          let height = widget.render_overlap(text_area, frame.buffer_mut());

          // Copy the drawn result to a buffer for caching
          let mut buf = ratatui::buffer::Buffer::empty(Rect {
            x: 0,
            y: 0,
            width: text_area.width,
            height,
          });
          for y in 0..height {
            // TODO: only copy the width actually drawn by the widget
            for x in 0..text_area.width {
              *buf.get_mut(x, y) = frame
                .buffer_mut()
                .get(text_area.x + x, text_area.y + text_area.height + y - height)
                .clone()
            }
          }

          *prerender = Some(PrerenderInner {
            key: text_area.width,
            value: PrerenderValue::Rendered(buf),
          });

          height
        },
      };

      assert!(area.height >= height, "{:?} {}", area, height);
      text_area.height = text_area.height.saturating_sub(height); // Remove lines at the bottom used by this paragraph
      if text_area.height == 0 {
        // No more room to display other paragraphs, stop now
        return Ok(());
      }
    }

    // There is empty room on screen, ask the buffer to fetch more backlog if it can
    active_buffer.request_back_pagination(100);

    Ok(())
  }
}