(** This module represent a sheet *)

type cell = int * int
  
module Raw: sig

  exception Cycle
  
  type t
  
  (** Create a new sheet *)
  val create: 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
  
  val get_value: cell -> t -> ScTypes.result
  
  val get_expr: cell -> t -> Expression.t

  val get_sink: cell -> t -> Cell.Set.t
  
  val fold: ('a -> cell -> (Expression.t * ScTypes.result ) -> 'a) -> 'a -> t -> 'a

end

type yank

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

type search = [
  | `Pattern of ScTypes.result
  | `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

val add: Expression.t -> t -> Cell.Set.t * t

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