(** This module represent a sheet *)

type cell = int * int
  
module Raw: sig

  type t
  
  (** An empty sheet *)
  val empty: t
  
  (** Add a new value in the sheet. The previous value is replaced 
    @return All the successors to update and the new sheet.
  *)
  val add: cell -> Expression.t -> t -> Cell.Set.t * t
  
  val remove: cell -> t -> Cell.Set.t * t

  (** Get the value content. 
      @return None if the cell is not defined
   *)
  val get_value: cell -> t -> ScTypes.result option
  
  val get_expr: cell -> t -> Expression.t

  val get_sink: cell -> t -> Cell.Set.t
  
  (** Fold over all the defined values *)
  val fold: ('a -> cell -> (Expression.t * ScTypes.result ) -> 'a) -> 'a -> t -> 'a

end

type yank
type history

type t = {
  selected: Selection.t;    (* The selected cell *)
  data: Raw.t;
  history: history;    (* Unlimited history *)
  yank: yank list           (* All the selected cells *)
}

type search = [
  | `Pattern of ScTypes.result option
  | `Next
  | `Previous
]

(** Undo the last action and return the previous state, if any *)
val undo: t -> t option

(** Move the cursor in one direction, return the state updated if the move is
    allowed *) 
val move: Actions.direction -> t -> t option

(** Delete the content of selected cells.
    @return The sheet and the number of cells deleted
*)
val delete: t -> t * int

(** Copy the selected cells 
    @return The sheet and the number of cells deleted
*)
val yank: t -> t * int

(** Search for a pattern on the sheet 
    @return The state updated if the pattern has been found. *)
val search: search -> t -> t option

val paste: t -> t * int

(** Add or update the sheet.
    The expression is added at current selection.
    @return A set containing all updated cells, and the tree updated. *)
val add: Expression.t -> t -> Cell.Set.t * t

(** Create an empty sheet *)
val create: Raw.t -> t