| .left => if c' > bc then some p else some acc.get!
         | .right => if c' < bc then some p else some acc.get!
         | .up => if r' > br then some p else some acc.get!
         | .down => if r' < br then some p else some acc.get!

         | .left => if c' > bc then some p else acc
         | .right => if c' < bc then some p else acc
         | .up => if r' > br then some p else acc
         | .down => if r' < br then some p else acc

  searchBloomBuildSizeThreshold : Nat := 524288

  searchBloomBuildSizeThreshold := 524288

private def updateLineIndexOnInsert (_pt : PieceTable) (_offset : Nat) (_text : String) : Option (Array Nat) :=
  none

private def updateLineIndexOnDelete (_pt : PieceTable) (_offset : Nat) (_length : Nat) : Option (Array Nat) :=
  none

def PieceTable.fromByteArray (bytes : ByteArray) (buildLeafBits : Bool := true) (buildOnEdit : Bool := false) : PieceTable :=

def PieceTable.fromByteArray (bytes : ByteArray) (buildLeafBits : Bool := true) (buildOnEdit : Bool := false) (threshold : Nat := 524288) : PieceTable :=

      original := bytes, addBuffers := #[], tree := PieceTree.empty, bloomBuildLeafBits := buildLeafBits, bloomBuildOnEdit := true,

      original := bytes, addBuffers := #[], tree := PieceTree.empty, bloomBuildLeafBits := buildLeafBits, bloomBuildOnEdit := buildLeafBits && bytes.size < threshold,

def PieceTable.fromString (s : String) (buildLeafBits : Bool := true) (buildOnEdit : Bool := false) : PieceTable :=
  PieceTable.fromByteArray s.toUTF8 buildLeafBits buildOnEdit

def PieceTable.fromString (s : String) (buildLeafBits : Bool := true) (buildOnEdit : Bool := false) (threshold : Nat := 524288) : PieceTable :=
  PieceTable.fromByteArray s.toUTF8 buildLeafBits buildOnEdit threshold
def PieceTable.rebuildBlooms (pt : PieceTable) : PieceTable :=
  { pt with tree := PieceTree.rebuildBloomsForTree pt.tree pt }

      lineIndexCache := updateLineIndexOnInsert pt offset text

      lineIndexCache := none

      lineIndexCache := updateLineIndexOnDelete pt offset length

      lineIndexCache := none

      lineIndexCache := updateLineIndexOnInsert pt offset text

      lineIndexCache := none

      lineIndexCache := updateLineIndexOnDelete pt offset length

      lineIndexCache := none

  Id.run do
    let mut cumBytes : Array UInt64 := #[0]
    let mut cumLines : Array UInt64 := #[0]
    let mut cumChars : Array UInt64 := #[0]
    for i in [0:children.size] do
      let child := children[i]!

  let (cumBytes, cumLines, cumChars) := children.foldl
    (fun (cb, cl, cc) child =>

      (cb.push (cb.back! + s.bytes), cl.push (cl.back! + s.lines), cc.push (cc.back! + s.chars)))
    (#[0], #[0], #[0])
  { cumulativeBytes := cumBytes, cumulativeLines := cumLines, cumulativeChars := cumChars }

      let prevBytes := cumBytes.back!
      let prevLines := cumLines.back!
      let prevChars := cumChars.back!
      cumBytes := cumBytes.push (prevBytes + s.bytes)
      cumLines := cumLines.push (prevLines + s.lines)
      cumChars := cumChars.push (prevChars + s.chars)
    return {
      cumulativeBytes := cumBytes,
      cumulativeLines := cumLines,
      cumulativeChars := cumChars
    }

def buildBloomForChildren (children : Array ViE.PieceTree) : ViE.SearchBloom := Id.run do
  if children.isEmpty then
    return ViE.SearchBloom.empty
  let mut acc := searchMetaOf children[0]!
  for i in [1:children.size] do
    acc := combineBloom acc (searchMetaOf children[i]!)
  return acc

def buildBloomForChildren (children : Array ViE.PieceTree) : ViE.SearchBloom :=
  match children[0]? with
  | none => ViE.SearchBloom.empty
  | some first =>
      (children.extract 1 children.size).foldl
        (fun acc child => combineBloom acc (searchMetaOf child))
        (searchMetaOf first)

def patternTrigramHashes (pattern : ByteArray) : Array (Nat × Nat) := Id.run do
  if pattern.size < 3 then
    return #[]
  let arr := pattern.data
  let limit := pattern.size - 2
  let mut hashes : Array (Nat × Nat) := #[]
  for i in [0:limit] do
    let b0 := arr[i]!
    let b1 := arr[i + 1]!
    let b2 := arr[i + 2]!
    hashes := hashes.push (hash1 b0 b1 b2, hash2 b0 b1 b2)
  return hashes

def patternTrigramHashes (pattern : ByteArray) : Array (Nat × Nat) :=
  if pattern.size < 3 then #[]
  else
    let arr := pattern.data
    (Array.range (pattern.size - 2)).map fun i =>
      (hash1 arr[i]! arr[i + 1]! arr[i + 2]!, hash2 arr[i]! arr[i + 1]! arr[i + 2]!)

/-- Traverse the tree and rebuild bloom bits for every leaf node.
    Used by :bloom on-demand build for files that exceeded the load-time threshold. -/
partial def rebuildBloomsForTree (t : ViE.PieceTree) (pt : ViE.PieceTable) : ViE.PieceTree :=
  let buildPt := { pt with bloomBuildLeafBits := true, bloomBuildOnEdit := true }
  match t with
  | ViE.PieceTree.empty => ViE.PieceTree.empty
  | ViE.PieceTree.leaf pieces s _ =>
      ViE.PieceTree.leaf pieces s (buildBloomForPieces pieces buildPt)
  | ViE.PieceTree.internal children s _ im =>
      let newChildren := children.map (rebuildBloomsForTree · pt)
      ViE.PieceTree.internal newChildren s (buildBloomForChildren newChildren) im

    let s' := ViE.startOrUpdateSearch state pattern direction true

    let state' :=
      if state.config.searchBloomBuildLeafBits then
        let activeBuf := state.getActiveBuffer
        if !(ViE.PieceTree.searchMetaOf activeBuf.table.tree).hasBits then
          state.updateActiveBuffer fun buf => { buf with table := buf.table.rebuildBlooms }
        else state
      else state
    let s' := ViE.startOrUpdateSearch state' pattern direction true

  let buffers := ws.buffers.filter (fun b => b.filename.isSome)

  -- Exclude virtual buffers (explorer/preview) so they are not treated as real files on restore.
  let buffers := ws.buffers.filter (fun b =>
    match b.filename with
    | some fname => !fname.startsWith "explorer://" && !fname.startsWith "preview://"
    | none => false)

    content := content ++ b.filename.get! ++ "\n"
    if b.id == activeBuffer.id then
       let cursor := state.getCursor
       content := content ++ s!"{cursor.row} {cursor.col}\n"
    else
       content := content ++ "0 0\n"

    if let some fname := b.filename then
      content := content ++ fname ++ "\n"
      if b.id == activeBuffer.id then
         let cursor := state.getCursor
         content := content ++ s!"{cursor.row} {cursor.col}\n"
      else
         content := content ++ "0 0\n"

def bufferFromData (filename : String) (data : ByteArray) (buildLeafBits buildOnEdit : Bool) : FileBuffer :=

def bufferFromData (filename : String) (data : ByteArray) (buildLeafBits buildOnEdit : Bool) (threshold : Nat := 524288) : FileBuffer :=

  let table := PieceTable.fromByteArray data buildLeafBits buildOnEdit

  let table := PieceTable.fromByteArray data buildLeafBits buildOnEdit threshold

  let threshold := config.searchBloomBuildSizeThreshold

            let buf := bufferFromData filename data buildLeafBits buildOnEdit

            let buf := bufferFromData filename data buildLeafBits buildOnEdit threshold

  -- View
  showLineNumbers := true

  showLineNumbers := false

  resetStyle := ViE.Color.reset

  searchBloomBuildSizeThreshold := 524288