AppFlowy/frontend/rust-lib/flowy-client-sync/src/client_document/document_pad.rs

use crate::{
  client_document::{
    history::{History, UndoResult},
    view::{ViewExtensions, RECORD_THRESHOLD},
  },
  errors::SyncError,
};
use bytes::Bytes;
use lib_infra::util::md5;
use lib_ot::text_delta::DeltaTextOperationBuilder;
use lib_ot::{core::*, text_delta::DeltaTextOperations};
use tokio::sync::mpsc;

pub trait InitialDocument {
  fn json_str() -> String;
}

pub struct EmptyDocument();
impl InitialDocument for EmptyDocument {
  fn json_str() -> String {
    DeltaTextOperations::default().json_str()
  }
}

pub struct NewlineDocument();
impl InitialDocument for NewlineDocument {
  fn json_str() -> String {
    initial_delta_document_content()
  }
}

pub fn initial_delta_document_content() -> String {
  DeltaTextOperationBuilder::new()
    .insert("\n")
    .build()
    .json_str()
}

pub struct ClientDocument {
  operations: DeltaTextOperations,
  history: History,
  view: ViewExtensions,
  last_edit_time: usize,
  notify: Option<mpsc::UnboundedSender<()>>,
}

impl ClientDocument {
  pub fn new<C: InitialDocument>() -> Self {
    let content = C::json_str();
    Self::from_json(&content).unwrap()
  }

  pub fn from_operations(operations: DeltaTextOperations) -> Self {
    ClientDocument {
      operations,
      history: History::new(),
      view: ViewExtensions::new(),
      last_edit_time: 0,
      notify: None,
    }
  }

  pub fn from_json(json: &str) -> Result<Self, SyncError> {
    let operations = DeltaTextOperations::from_json(json)?;
    Ok(Self::from_operations(operations))
  }

  pub fn get_operations_json(&self) -> String {
    self.operations.json_str()
  }

  pub fn to_bytes(&self) -> Bytes {
    self.operations.json_bytes()
  }

  pub fn to_content(&self) -> String {
    self.operations.content().unwrap()
  }

  pub fn get_operations(&self) -> &DeltaTextOperations {
    &self.operations
  }

  pub fn document_md5(&self) -> String {
    let bytes = self.to_bytes();
    md5(&bytes)
  }

  pub fn set_notify(&mut self, notify: mpsc::UnboundedSender<()>) {
    self.notify = Some(notify);
  }

  pub fn set_operations(&mut self, operations: DeltaTextOperations) {
    tracing::trace!("document: {}", operations.json_str());
    self.operations = operations;

    match &self.notify {
      None => {},
      Some(notify) => {
        let _ = notify.send(());
      },
    }
  }

  pub fn compose_operations(&mut self, operations: DeltaTextOperations) -> Result<(), SyncError> {
    tracing::trace!(
      "{} compose {}",
      &self.operations.json_str(),
      operations.json_str()
    );
    let composed_operations = self.operations.compose(&operations)?;
    let mut undo_operations = operations.invert(&self.operations);

    let now = chrono::Utc::now().timestamp_millis() as usize;
    if now - self.last_edit_time < RECORD_THRESHOLD {
      if let Some(last_operation) = self.history.undo() {
        tracing::trace!("compose previous change");
        tracing::trace!("current = {}", undo_operations);
        tracing::trace!("previous = {}", last_operation);
        undo_operations = undo_operations.compose(&last_operation)?;
      }
    } else {
      self.last_edit_time = now;
    }

    if !undo_operations.is_empty() {
      tracing::trace!("add history operations: {}", undo_operations);
      self.history.record(undo_operations);
    }

    self.set_operations(composed_operations);
    Ok(())
  }

  pub fn insert<T: ToString>(
    &mut self,
    index: usize,
    data: T,
  ) -> Result<DeltaTextOperations, SyncError> {
    let text = data.to_string();
    let interval = Interval::new(index, index);
    validate_interval(&self.operations, &interval)?;
    let operations = self.view.insert(&self.operations, &text, interval)?;
    self.compose_operations(operations.clone())?;
    Ok(operations)
  }

  pub fn delete(&mut self, interval: Interval) -> Result<DeltaTextOperations, SyncError> {
    validate_interval(&self.operations, &interval)?;
    debug_assert!(!interval.is_empty());
    let operations = self.view.delete(&self.operations, interval)?;
    if !operations.is_empty() {
      self.compose_operations(operations.clone())?;
    }
    Ok(operations)
  }

  pub fn format(
    &mut self,
    interval: Interval,
    attribute: AttributeEntry,
  ) -> Result<DeltaTextOperations, SyncError> {
    validate_interval(&self.operations, &interval)?;
    tracing::trace!("format {} with {:?}", interval, attribute);
    let operations = self
      .view
      .format(&self.operations, attribute, interval)
      .unwrap();
    self.compose_operations(operations.clone())?;
    Ok(operations)
  }

  pub fn replace<T: ToString>(
    &mut self,
    interval: Interval,
    data: T,
  ) -> Result<DeltaTextOperations, SyncError> {
    validate_interval(&self.operations, &interval)?;
    let mut operations = DeltaTextOperations::default();
    let text = data.to_string();
    if !text.is_empty() {
      operations = self.view.insert(&self.operations, &text, interval)?;
      self.compose_operations(operations.clone())?;
    }

    if !interval.is_empty() {
      let delete = self.delete(interval)?;
      operations = operations.compose(&delete)?;
    }

    Ok(operations)
  }

  pub fn can_undo(&self) -> bool {
    self.history.can_undo()
  }

  pub fn can_redo(&self) -> bool {
    self.history.can_redo()
  }

  pub fn undo(&mut self) -> Result<UndoResult, SyncError> {
    match self.history.undo() {
      None => Err(SyncError::undo().context("Undo stack is empty")),
      Some(undo_operations) => {
        let (new_operations, inverted_operations) = self.invert(&undo_operations)?;
        self.set_operations(new_operations);
        self.history.add_redo(inverted_operations);
        Ok(UndoResult {
          operations: undo_operations,
        })
      },
    }
  }

  pub fn redo(&mut self) -> Result<UndoResult, SyncError> {
    match self.history.redo() {
      None => Err(SyncError::redo()),
      Some(redo_operations) => {
        let (new_operations, inverted_operations) = self.invert(&redo_operations)?;
        self.set_operations(new_operations);
        self.history.add_undo(inverted_operations);
        Ok(UndoResult {
          operations: redo_operations,
        })
      },
    }
  }

  pub fn is_empty(&self) -> bool {
    // The document is empty if its text is equal to the initial text.
    self.operations.json_str() == NewlineDocument::json_str()
  }
}

impl ClientDocument {
  fn invert(
    &self,
    operations: &DeltaTextOperations,
  ) -> Result<(DeltaTextOperations, DeltaTextOperations), SyncError> {
    // c = a.compose(b)
    // d = b.invert(a)
    // a = c.compose(d)
    let new_operations = self.operations.compose(operations)?;
    let inverted_operations = operations.invert(&self.operations);
    Ok((new_operations, inverted_operations))
  }
}

fn validate_interval(
  operations: &DeltaTextOperations,
  interval: &Interval,
) -> Result<(), SyncError> {
  if operations.utf16_target_len < interval.end {
    tracing::error!(
      "{:?} out of bounds. should 0..{}",
      interval,
      operations.utf16_target_len
    );
    return Err(SyncError::out_of_bound());
  }
  Ok(())
}