signature MAKE_NORMAL_DELETE =
sig
  val initMsgs: int * int * LineGap.t -> MailboxType.t list
end

functor MakeNormalDelete(Fn: MAKE_NORMAL_DELETE) =
struct
  open AppType
  open DrawMsg
  open MailboxType

  fun finishAfterDeletingBuffer (app: app_type, low, buffer, time, msgs) =
    let
      val (buffer, searchList) = SearchList.build (buffer, #dfa app)
      val buffer = LineGap.goToIdx (low, buffer)
    in
      NormalFinish.buildTextAndClear (app, buffer, low, searchList, msgs, time)
    end

  fun deleteAndFinish (app: app_type, low, length, buffer, time) =
    let
      val buffer = LineGap.goToIdx (low + length, buffer)
      val initialMsg = Fn.initMsgs (low, length, buffer)
      val buffer = LineGap.delete (low, length, buffer)
    in
      finishAfterDeletingBuffer (app, low, buffer, time, initialMsg)
    end

  fun moveCursorAfterDeletingLines (app, buffer, time, initialMsg, startIdx) =
    let
      val newEndIdx = #textLength buffer - 1
    in
      if newEndIdx < 0 then
        (* deleted whole file; add newline to the end *)
        let val buffer = LineGap.append ("\n", buffer)
        in finishAfterDeletingBuffer (app, 0, buffer, time, initialMsg)
        end
      else if newEndIdx = 0 then
        (* there is only one char left in the file *)
        finishAfterDeletingBuffer (app, 0, buffer, time, initialMsg)
      else if startIdx >= newEndIdx then
        (* deleted the last part of the file such that the cursor's idx
         * now refers to an index that no longer exists.
         * Have to move cursor to the last line of the file. *)
        let
          val buffer = LineGap.goToIdx (newEndIdx, buffer)
        in
          if Cursor.isOnNewlineAfterChr (buffer, newEndIdx) then
            let
              val buffer = LineGap.goToIdx (newEndIdx - 1, buffer)
              val newCursorIdx = Cursor.vi0 (buffer, newEndIdx - 1)
            in
              finishAfterDeletingBuffer
                (app, newCursorIdx, buffer, time, initialMsg)
            end
          else
            let
              val newCursorIdx = Cursor.vi0 (buffer, newEndIdx)
            in
              finishAfterDeletingBuffer
                (app, newCursorIdx, buffer, time, initialMsg)
            end
        end
      else
        finishAfterDeletingBuffer (app, startIdx, buffer, time, initialMsg)
    end

  (* equivalent of vi's 'x' command **)
  fun removeChr (app: app_type, count, time) =
    let
      val {buffer, cursorIdx, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)
    in
      if Cursor.isCursorAtStartOfLine (buffer, cursorIdx) then
        NormalFinish.clearMode app
      else
        let
          val lineStart = Cursor.vi0 (buffer, cursorIdx)
          val lineEnd = Cursor.viDlrForDelete (buffer, cursorIdx, 1)
          val buffer = LineGap.goToIdx (lineEnd, buffer)

          (* if specified length (cursorIdx + count) extends 
           * beyond current line's length,
          *  then clip the length, to ensure we don't delete the newline *)
          val high = cursorIdx + count
          val high =
            if Cursor.isOnNewlineAfterChr (buffer, lineEnd) then lineEnd
            else Int.min (lineEnd - 1, high)
          val length = high - cursorIdx

          val initialMsg = Fn.initMsgs (cursorIdx, length, buffer)
          val buffer = LineGap.delete (cursorIdx, length, buffer)

          (* figure out where to place cursor *)
          val buffer = LineGap.goToIdx (lineStart, buffer)
          val lineEndAfterDelete = Cursor.viDlr (buffer, lineStart, 1)

          val cursorIdx = Int.min (lineEndAfterDelete, cursorIdx)
        in
          if cursorIdx >= #textLength buffer - 1 then
            (* special case: when buffer does not end with newline
             * and we are deleting from the last line *)
            let
              val cursorIdx = #textLength buffer - 1
              val buffer = LineGap.goToIdx (cursorIdx, buffer)
              val cursorIdx =
                if Cursor.isOnNewlineAfterChr (buffer, cursorIdx) then
                  cursorIdx - 1
                else
                  cursorIdx
            in
              finishAfterDeletingBuffer
                (app, cursorIdx, buffer, time, initialMsg)
            end
          else
            finishAfterDeletingBuffer (app, cursorIdx, buffer, time, initialMsg)
        end
    end

  (* Note: The below implementation of removing line breaks with the 'J' 
   * command slightly differs from the implementation in Vim.
   * In Vim, the J, 1J, and 2J commands all have the same effect.
   * 3J, 4J, 5J, etc. all have different effects because of the different counts
   * though.
   * Our implementation has a different effect for each count. 
   * 1J delettes 1 line break, 2J deletes 2, and so on. *)
  fun helpRemoveLineBreaks (app, buffer, cursorIdx, count, time) =
    if count = 0 then
      (* we don't use Fn.initMsgs in this function.
       * Removing line breaks is a discrete action which doesn't operate
       * as a range the way that motions like 'dw' or 'diw'.
       * Instead, a single character is deleted at different places. 
       * So it doesn't make any sense to use Fn.initMsgs 
       * which expects a range. *)
      finishAfterDeletingBuffer (app, cursorIdx, buffer, time, [])
    else
      let
        val buffer = LineGap.goToIdx (cursorIdx, buffer)
      in
        if Cursor.isCursorAtStartOfLine (buffer, cursorIdx) then
          if cursorIdx >= #textLength buffer - 2 then
            finishAfterDeletingBuffer (app, cursorIdx, buffer, time, [])
          else
            (* if the cursor is at a linebreak, delete the linebreak
             * and don't insert a space. *)
            let val buffer = LineGap.delete (cursorIdx, 1, buffer)
            in helpRemoveLineBreaks (app, buffer, cursorIdx, count - 1, time)
            end
        else
          let
            val newCursorIdx =
              Cursor.toNextChrNew
                (buffer, cursorIdx, {findChr = #"\n", count = 1})
          in
            if newCursorIdx >= #textLength buffer - 2 then
              finishAfterDeletingBuffer (app, cursorIdx, buffer, time, [])
            else
              let
                val buffer = LineGap.delete (newCursorIdx, 1, buffer)
                val buffer = LineGap.insert (newCursorIdx, " ", buffer)
              in
                helpRemoveLineBreaks
                  (app, buffer, newCursorIdx, count - 1, time)
              end
          end
      end

  fun removeLineBreaks (app: app_type, count, time) =
    let
      val {buffer, cursorIdx, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)
    in
      if Cursor.isCursorAtStartOfLine (buffer, cursorIdx) then
        if cursorIdx >= #textLength buffer - 2 then
          NormalFinish.clearMode app
        else
          let val buffer = LineGap.delete (cursorIdx, 1, buffer)
          in helpRemoveLineBreaks (app, buffer, cursorIdx, count - 1, time)
          end
      else
        let
          val buffer = LineGap.goToIdx (cursorIdx, buffer)
          val newCursorIdx =
            Cursor.toNextChrNew
              (buffer, cursorIdx, {findChr = #"\n", count = 1})
          val buffer = LineGap.goToIdx (newCursorIdx, buffer)
        in
          if
            cursorIdx = newCursorIdx
            orelse newCursorIdx >= #textLength buffer - 2
          then
            (* no change, either because no #"\n" was found
             * or because the next #"\n" found is the last character in the
             * file.
             * We don't delete the last #"\n" in the file
             * because Unix convention is that text files always
             * end with newlines. *)
            NormalFinish.clearMode app
          else
            let
              val buffer = LineGap.delete (newCursorIdx, 1, buffer)
              val buffer = LineGap.insert (newCursorIdx, " ", buffer)
            in
              helpRemoveLineBreaks (app, buffer, newCursorIdx, count - 1, time)
            end
        end
    end

  fun helpDelete
    (app: app_type, buffer, cursorIdx, otherIdx, count, fMove, time) =
    (* As a small optimisation to reduce allocations, 
    * we accumulate otherIdx by calling fMove with it and the buffer
    * on each loop.
    * Then, at the end of the loop, we perform the actual deletion.
    * This is faster than performing the actual deletion on every loop
    * because we only delete once, and avoid allocating intermediary buffers.
    * The behaviour between the two is equivalent. *)
    if count = 0 then
      let
        val low = Int.min (cursorIdx, otherIdx)
        val high = Int.max (cursorIdx, otherIdx)
        val high =
          if high >= #textLength buffer - 2 then
            Int.max (#textLength buffer - 2, 0)
          else
            high
        val length = high - low

        val buffer = LineGap.goToIdx (high, buffer)
        val initialMsg = Fn.initMsgs (low, length, buffer)

        val buffer = LineGap.delete (low, length, buffer)
        val (buffer, searchList) = SearchList.build (buffer, #dfa app)

        (* If we have deleted from the buffer so that cursorIdx
        * is no longer a valid idx,
        * clip cursorIdx to the end. *)
        val buffer = LineGap.goToIdx (low, buffer)
        val cursorIdx =
          if low >= #textLength buffer then
            Int.max (#textLength buffer - 2, low)
          else
            low
      in
        NormalFinish.buildTextAndClear
          (app, buffer, cursorIdx, searchList, initialMsg, time)
      end
    else
      let
        (* get otherIdx, where cursor will want to go after motion. *)
        val buffer = LineGap.goToIdx (otherIdx, buffer)
        val newOtherIdx = fMove (buffer, otherIdx)
        val newCount = if newOtherIdx = otherIdx then 0 else count - 1
      in
        helpDelete (app, buffer, cursorIdx, newOtherIdx, newCount, fMove, time)
      end

  fun delete (app: app_type, count, fMove, time) =
    let val {buffer, cursorIdx, ...} = app
    in helpDelete (app, buffer, cursorIdx, cursorIdx, count, fMove, time)
    end

  fun finishDeleteByDfa (app, low, high, buffer, time) =
    let
      val buffer = LineGap.goToIdx (high, buffer)
      val high =
        (* by default, we have a newline at the end of the buffer.
         * However, we also support the case where there is no newline
         * at the end of the buffer.
         * The first case is supported by default,
         * but we have to increment the textLength if the buffer
         * does not end with a newline, to make sure that
         * we delete the last character. *)
        if
          high = #textLength buffer - 1
          andalso not (Cursor.isCursorAtStartOfLine (buffer, high))
        then #textLength buffer
        else high

      val length = high - low
      val initialMsg = Fn.initMsgs (low, length, buffer)
      val buffer = LineGap.delete (low, length, buffer)

      (* if we deleted all text in the buffer, 
       * then make sure that we append a newline at the end
       * so that the buffer contains at least one character *)
      val buffer =
        if #textLength buffer = 0 then LineGap.append ("\n", buffer) else buffer
    in
      if low >= #textLength buffer - 1 andalso #textLength buffer > 0 then
        (* edge case:
         * when we delete from the cursor's position to the end of a file,
         * we have to move the cursor to be on the last char
         * because the original cursor's position is no longer valid. *)
        let
          val newCursorIdx = Int.max (#textLength buffer - 1, 0)
          val buffer = LineGap.goToIdx (newCursorIdx, buffer)
          val newCursorIdx =
            if Cursor.isOnNewlineAfterChr (buffer, newCursorIdx) then
              newCursorIdx - 1
            else
              newCursorIdx
        in
          finishAfterDeletingBuffer
            (app, newCursorIdx, buffer, time, initialMsg)
        end
      else
        let
          val buffer = LineGap.goToIdx (low, buffer)
          val newCursorIdx =
            if Cursor.isOnNewlineAfterChr (buffer, low) then low - 1 else low
        in
          finishAfterDeletingBuffer
            (app, newCursorIdx, buffer, time, initialMsg)
        end
    end

  fun deleteByDfa (app as {buffer, ...}: app_type, count, fMove, time) =
    if #textLength buffer = 1 then
      NormalFinish.clearMode app
    else
      let
        val {buffer, cursorIdx, ...} = app

        val buffer = LineGap.goToIdx (cursorIdx, buffer)
        val otherIdx = fMove (buffer, cursorIdx, count)
      in
        if otherIdx > cursorIdx then
          if otherIdx >= #textLength buffer then
            (* prevent us from deleting last newline
             * to help us preserve unix-style line endings *)
            let
              (* if we're on the first character/column in a line,
               * we would like to delete the preceding newline too *)
              val cursorIdx =
                if Cursor.isPrevChrStartOfLine (buffer, cursorIdx) then
                  cursorIdx - 1
                else
                  cursorIdx
              val high = #textLength buffer - 1
            in
              finishDeleteByDfa (app, cursorIdx, high, buffer, time)
            end
          else
            finishDeleteByDfa (app, cursorIdx, otherIdx, buffer, time)
        else if otherIdx < cursorIdx then
          finishDeleteByDfa (app, otherIdx, cursorIdx, buffer, time)
        else
          NormalFinish.clearMode app
      end

  fun deleteCharsLeft (app: app_type, count, time) =
    let
      val {buffer, cursorIdx, ...} = app

      val buffer = LineGap.goToIdx (cursorIdx, buffer)
      val startOfLine = Cursor.vi0 (buffer, cursorIdx)
      val low = Cursor.viH (buffer, cursorIdx, count)
      val low = if low < startOfLine then startOfLine else low

      val length = cursorIdx - low
    in
      deleteAndFinish (app, low, length, buffer, time)
    end

  fun deleteToEndOfPrevWord (app: app_type, count, time) =
    if #cursorIdx app = 0 then
      NormalFinish.clearMode app
    else
      let
        val {buffer, cursorIdx, ...} = app

        val buffer = LineGap.goToIdx (cursorIdx, buffer)
        val low = Cursor.endOfPrevWord (buffer, cursorIdx, count)

        val length = (cursorIdx + 1) - low

        val buffer = LineGap.goToIdx (cursorIdx + 1, buffer)
        val initialMsg = Fn.initMsgs (low, length, buffer)
        val buffer = LineGap.delete (low, length, buffer)

        val buffer = LineGap.goToIdx (low, buffer)
        val newCursorIdx =
          if Cursor.isOnNewlineAfterChr (buffer, low) then Int.max (low - 1, 0)
          else low
      in
        finishAfterDeletingBuffer (app, newCursorIdx, buffer, time, initialMsg)
      end

  fun deleteToEndOfPrevWORD (app: app_type, count, time) =
    if #cursorIdx app = 0 then
      NormalFinish.clearMode app
    else
      let
        val {buffer, cursorIdx, ...} = app

        val buffer = LineGap.goToIdx (cursorIdx, buffer)
        val low = Cursor.endOfPrevWORD (buffer, cursorIdx, count)

        val length = (cursorIdx + 1) - low

        val buffer = LineGap.goToIdx (cursorIdx + 1, buffer)
        val initialMsg = Fn.initMsgs (low, length, buffer)
        val buffer = LineGap.delete (low, length, buffer)

        val buffer = LineGap.goToIdx (low, buffer)
        val newCursorIdx =
          if Cursor.isOnNewlineAfterChr (buffer, low) then Int.max (low - 1, 0)
          else low
      in
        finishAfterDeletingBuffer (app, newCursorIdx, buffer, time, initialMsg)
      end

  fun deleteToEndOfLine (app: app_type, time) =
    let
      val {buffer, cursorIdx, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)
    in
      if Cursor.isCursorAtStartOfLine (buffer, cursorIdx) then
        (* if we are on \n, we don't want to delete or do anything
        * so reset the mode *)
        NormalFinish.clearMode app
      else
        let
          val lineStart = Cursor.vi0 (buffer, cursorIdx)
          val high = Cursor.viDlr (buffer, cursorIdx, 1) + 1
          val length = high - cursorIdx

          val buffer = LineGap.goToIdx (high, buffer)
          val initialMsg = Fn.initMsgs (cursorIdx, length, buffer)
          val buffer = LineGap.delete (cursorIdx, length, buffer)

          (* calculate new cursorIdx.
           * Because we deleted the cursor that this line is on,
           * we need to set the cursorIdx to the place
           * that is considered to be the "end of line"
           * after having performed the deletion. *)
          val buffer = LineGap.goToIdx (lineStart, buffer)
          val cursorIdx = Cursor.viDlr (buffer, lineStart, 1)
          val buffer = LineGap.goToIdx (cursorIdx, buffer)
          val cursorIdx =
            if Cursor.isOnNewlineAfterChr (buffer, cursorIdx) then cursorIdx - 1
            else cursorIdx
        in
          finishAfterDeletingBuffer (app, cursorIdx, buffer, time, initialMsg)
        end
    end

  fun deleteLine (app: app_type, count, time) =
    let
      val {buffer, cursorIdx, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)

      val startIdx = Cursor.vi0 (buffer, cursorIdx)
      val buffer = LineGap.goToIdx (startIdx, buffer)

      val startLine =
        if Cursor.isCursorAtStartOfLine (buffer, startIdx) then
          LineGap.idxToLineNumber (startIdx, buffer)
        else
          LineGap.idxToLineNumber (startIdx + 1, buffer)
      val endLine = startLine + count

      val buffer = LineGap.goToLine (endLine, buffer)
      val endLineIdx = LineGap.lineNumberToIdx (endLine, buffer)
      val buffer = LineGap.goToIdx (endLineIdx, buffer)
      val endLineIdx =
        if Cursor.isCursorAtStartOfLine (buffer, endLineIdx) then endLineIdx + 1
        else endLineIdx

      val length = endLineIdx - startIdx
      val initialMsg = Fn.initMsgs (startIdx, length, buffer)
      val buffer = LineGap.delete (startIdx, length, buffer)
    in
      (* just need to reposition the cursor *)
      moveCursorAfterDeletingLines (app, buffer, time, initialMsg, startIdx)
    end

  fun deleteLineDown (app: app_type, count, time) =
    let
      val {buffer, cursorIdx, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)

      val startIdx = Cursor.vi0 (buffer, cursorIdx)
      val buffer = LineGap.goToIdx (startIdx, buffer)

      val startLine =
        if Cursor.isCursorAtStartOfLine (buffer, startIdx) then
          LineGap.idxToLineNumber (startIdx, buffer)
        else
          LineGap.idxToLineNumber (startIdx + 1, buffer)
      val endLine = startLine + count + 1

      val buffer = LineGap.goToLine (endLine, buffer)
      val endLineIdx = LineGap.lineNumberToIdx (endLine, buffer)
      val buffer = LineGap.goToIdx (endLineIdx - 1, buffer)

      (* get "real" endLine by not considering newline after non-newline *)
      val endLine =
        if Cursor.isOnNewlineAfterChr (buffer, endLineIdx - 1) then
          LineGap.idxToLineNumber (endLineIdx - 1, buffer)
        else
          LineGap.idxToLineNumber (endLineIdx, buffer)
    in
      if endLineIdx = #textLength buffer andalso endLine = startLine then
        (* cursor is already on last line so not deleting *)
        NormalModeWith.bufferMsgsAndMode (app, buffer, [], NORMAL_MODE "")
      else
        let
          val buffer = LineGap.goToIdx (endLineIdx, buffer)

          (* right now, endLineIdx may be on a newline.
           * If it is, we want to delete that newline too,
           * and in that case, we increment by 1 to do so. 
           * However, we don't want to delete the last newline in the file
           * so we don't increment in that case. 
           * Edge case: if the startIdx also begins after a newline
           * then it is okay for us to delete the newline at the end of the file
           * because there will already be a newline at the end of the file
           * after the deletion. *)
          val endsOnNewline = Cursor.isCursorAtStartOfLine (buffer, endLineIdx)

          val buffer = LineGap.goToIdx (startIdx, buffer)
          val startsAfterNewline =
            startIdx > 0 andalso Cursor.isPrevChrStartOfLine (buffer, startIdx)

          val endLineIdx =
            if endsOnNewline then
              if endLineIdx = #textLength buffer - 1 then
                if startsAfterNewline then endLineIdx + 1 else endLineIdx
              else
                endLineIdx + 1
            else
              endLineIdx

          val length = endLineIdx - startIdx

          (* perform the actual deletion *)
          val buffer = LineGap.goToIdx (endLineIdx, buffer)
          val initialMsg = Fn.initMsgs (startIdx, length, buffer)
          val buffer = LineGap.delete (startIdx, length, buffer)
        in
          moveCursorAfterDeletingLines (app, buffer, time, initialMsg, startIdx)
        end
    end

  fun finishDeleteLineBack (app, buffer, lineIdx, length, endOfLine, time) =
    if endOfLine >= #textLength buffer - 2 then
      (* deleting from last line *)
      let
        (* go to first column of previous line *)
        val buffer = LineGap.goToIdx (endOfLine, buffer)
        val initialMsg = Fn.initMsgs (lineIdx, length, buffer)
        val buffer = LineGap.delete (lineIdx, length, buffer)

        val buffer =
          if #textLength buffer = 0 then LineGap.append ("\n", buffer)
          else buffer

        (* since we deleted from the last line,
         * we want to place the cursor at the first column
         * of the now-last line in the buffer. *)
        val newCursorIdx = Int.max (#textLength buffer - 1, 0)
        val buffer = LineGap.goToIdx (newCursorIdx, buffer)
        val newCursorIdx =
          if Cursor.isOnNewlineAfterChr (buffer, newCursorIdx) then
            newCursorIdx - 1
          else
            newCursorIdx
        val buffer = LineGap.goToIdx (newCursorIdx, buffer)
        val newCursorIdx = Cursor.vi0 (buffer, newCursorIdx)
      in
        finishAfterDeletingBuffer (app, newCursorIdx, buffer, time, initialMsg)
      end
    else
      let
        (* make sure the cursorIdx will be at the first column
         * of current line, after deleting from buffer. *)
        val buffer = LineGap.goToIdx (lineIdx, buffer)
        val newCursorIdx =
          if Cursor.isOnNewlineAfterChr (buffer, lineIdx) then lineIdx + 1
          else lineIdx

        val buffer = LineGap.goToIdx (endOfLine, buffer)
        val initialMsg = Fn.initMsgs (lineIdx, length, buffer)
        val buffer = LineGap.delete (lineIdx, length, buffer)

        val buffer =
          if #textLength buffer = 0 then LineGap.append ("\n", buffer)
          else buffer
      in
        finishAfterDeletingBuffer (app, newCursorIdx, buffer, time, initialMsg)
      end

  fun deleteLineBack (app: app_type, count, time) =
    let
      val {buffer, cursorIdx, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)

      val cursorLineNumber =
        if Cursor.isNextChrEndOfLine (buffer, cursorIdx) then
          LineGap.idxToLineNumber (cursorIdx + 1, buffer)
        else
          LineGap.idxToLineNumber (cursorIdx, buffer)
      val newCursorLineNumber = Int.max (cursorLineNumber - count, 0)
    in
      if cursorLineNumber = 0 then
        NormalFinish.clearMode app
      else if newCursorLineNumber = 0 then
        (* deleting from current line to start of file *)
        let
          val endOfLine = Cursor.viDlr (buffer, cursorIdx, 1)

          (* edge case: if cursor is on a newline (if endOfLine = cursorIdx)
           * then we only want to delete 1 character at this line, 
           * which is the newline the cursor is at.
           * Otherwise, we want to delete 2 chars by default. *)
          val buffer = LineGap.goToIdx (endOfLine, buffer)
          val endOfLine =
            if Cursor.isCursorAtStartOfLine (buffer, endOfLine) then
              endOfLine + 1
            else
              endOfLine + 2
        in
          finishDeleteLineBack (app, buffer, 0, endOfLine, endOfLine, time)
        end
      else
        let
          val endOfLine = Cursor.viDlr (buffer, cursorIdx, 1)
          val buffer = LineGap.goToIdx (endOfLine, buffer)
          val endsOnNewline = Cursor.isCursorAtStartOfLine (buffer, endOfLine)

          (* edge case: if cursor is on a newline,
           * then we don't want to delete the newline
           * as we are already deleting the newline 
           * at the start of this range *)
          val endOfLine = if endsOnNewline then endOfLine else endOfLine + 1

          val newCursorLineNumber =
            if endsOnNewline andalso endOfLine = #textLength buffer - 1 then
              newCursorLineNumber - 1
            else
              newCursorLineNumber
          val buffer = LineGap.goToLine (newCursorLineNumber, buffer)

          val lineIdx = LineGap.lineNumberToIdx (newCursorLineNumber, buffer)
          val length = endOfLine - lineIdx
        in
          finishDeleteLineBack (app, buffer, lineIdx, length, endOfLine, time)
        end
    end

  fun deleteToFirstNonSpaceChr (app: app_type, time) =
    let
      val {buffer, cursorIdx, ...} = app

      (* move LineGap and buffer to start of line *)
      val buffer = LineGap.goToIdx (cursorIdx, buffer)
      val otherIdx = Cursor.vi0 (buffer, cursorIdx)

      (* move cursorIdx to first character on line *)
      val buffer = LineGap.goToIdx (cursorIdx, buffer)
      val otherIdx = Cursor.firstNonSpaceChr (buffer, otherIdx)

      val low = Int.min (cursorIdx, otherIdx)
      val high = Int.max (cursorIdx, otherIdx)
      val length = high - low
    in
      deleteAndFinish (app, low, length, buffer, time)
    end

  fun finishDeleteToChr (app, buffer, cursorIdx, otherIdx, time) =
    let
      val low = Int.min (cursorIdx, otherIdx)
      val high = Int.max (cursorIdx, otherIdx)
      val length = high - low
    in
      deleteAndFinish (app, low, length, buffer, time)
    end

  fun helpDeleteToChr
    (app: app_type, buffer, cursorIdx, otherIdx, count, fMove, fInc, chr, time) =
    if count = 0 then
      finishDeleteToChr (app, buffer, cursorIdx, otherIdx, time)
    else
      let
        val buffer = LineGap.goToIdx (otherIdx, buffer)
        val newOtherIdx = fMove (buffer, otherIdx, chr)
      in
        if otherIdx = newOtherIdx then
          finishDeleteToChr (app, buffer, cursorIdx, otherIdx, time)
        else
          helpDeleteToChr
            ( app
            , buffer
            , cursorIdx
            , fInc (newOtherIdx, 1)
            , count - 1
            , fMove
            , fInc
            , chr
            , time
            )
      end

  fun deleteToChr (app: app_type, count, fMove, fInc, chr, time) =
    helpDeleteToChr
      ( app
      , #buffer app
      , #cursorIdx app
      , #cursorIdx app
      , count
      , fMove
      , fInc
      , chr
      , time
      )

  fun deleteToNextChr (app: app_type, count, chr, time) =
    let
      val {buffer, cursorIdx, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)
      val newCursorIdx =
        Cursor.toNextChrNew (buffer, cursorIdx, {findChr = chr, count = count})
    in
      if newCursorIdx = ~1 then
        NormalFinish.clearMode app
      else
        let
          val length = newCursorIdx - cursorIdx + 1
          val buffer = LineGap.goToIdx (newCursorIdx, buffer)
          val initialMsg = Fn.initMsgs (cursorIdx, length, buffer)
          val buffer = LineGap.delete (cursorIdx, length, buffer)

          val buffer =
            if #textLength buffer = 0 then LineGap.fromString "\n" else buffer

          val buffer = LineGap.goToIdx (cursorIdx, buffer)
          val cursorIdx =
            if Cursor.isOnNewlineAfterChr (buffer, cursorIdx) then cursorIdx - 1
            else cursorIdx
        in
          finishAfterDeletingBuffer (app, cursorIdx, buffer, time, initialMsg)
        end
    end

  fun deleteTillNextChr (app: app_type, count, chr, time) =
    let
      val {buffer, cursorIdx, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)
      val newCursorIdx =
        Cursor.toNextChrNew (buffer, cursorIdx, {findChr = chr, count = count})
    in
      if newCursorIdx = ~1 then
        NormalFinish.clearMode app
      else
        let val length = newCursorIdx - cursorIdx
        in deleteAndFinish (app, cursorIdx, length, buffer, time)
        end
    end

  fun deleteToStart (app: app_type, time) : AppType.app_type =
    let
      val {cursorIdx, buffer, windowWidth, windowHeight, dfa, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)
      val cursorIdx = Cursor.viDlrForDelete (buffer, cursorIdx, 1)

      val buffer = LineGap.goToIdx (cursorIdx, buffer)
      val initialMsg = Fn.initMsgs (0, cursorIdx, buffer)

      val buffer = LineGap.delete (0, cursorIdx, buffer)
      val buffer =
        if #textLength buffer = 0 then LineGap.fromString "\n" else buffer

      val buffer = LineGap.goToIdx (cursorIdx - 1111, buffer)
      val (buffer, searchList) = SearchList.build (buffer, dfa)

      val cursorIdx = 0
      val startLine = 0
      val visualScrollColumn = 0
      val buffer = LineGap.goToIdx (cursorIdx, buffer)

      val drawMsg = NormalModeTextBuilder.build
        ( startLine
        , cursorIdx
        , buffer
        , windowWidth
        , windowHeight
        , searchList
        , visualScrollColumn
        )
      val drawMsg = Vector.concat drawMsg
      val drawMsg = DRAW_TEXT drawMsg

      val msgs = DRAW drawMsg :: initialMsg
      val mode = NORMAL_MODE ""
    in
      NormalModeWith.bufferAndCursorIdx
        ( app
        , buffer
        , cursorIdx
        , mode
        , startLine
        , searchList
        , msgs
        , time
        , visualScrollColumn
        )
    end

  fun deleteToEnd (app: app_type, time) =
    let
      val {buffer, cursorIdx, ...} = app

      val buffer = LineGap.goToIdx (cursorIdx, buffer)
      val startOfLineIdx = Cursor.vi0 (buffer, cursorIdx)
      val length = #textLength buffer - startOfLineIdx

      val buffer = LineGap.goToIdx (#textLength buffer, buffer)
      val initialMsg = Fn.initMsgs (startOfLineIdx, length, buffer)

      val buffer = LineGap.delete (startOfLineIdx, length, buffer)
      val buffer =
        if #textLength buffer = 0 then LineGap.fromString "\n" else buffer

      val newLineEndIdx = Int.max (startOfLineIdx - 1, 0)
      val buffer = LineGap.goToIdx (newLineEndIdx, buffer)
      val newLineEndIdx =
        if Cursor.isOnNewlineAfterChr (buffer, newLineEndIdx) then
          Int.max (newLineEndIdx - 1, 0)
        else
          newLineEndIdx

      val buffer = LineGap.goToIdx (newLineEndIdx, buffer)
      val newLineStartIdx = Cursor.vi0 (buffer, newLineEndIdx)
    in
      finishAfterDeletingBuffer (app, newLineStartIdx, buffer, time, initialMsg)
    end

  fun helpDeleteToMatch (app: app_type, low, high, time) =
    let
      val {buffer, dfa, ...} = app
      val buffer = LineGap.goToIdx (high, buffer)
      val length = high - low
      val initialMsg = Fn.initMsgs (low, length, buffer)

      val buffer = LineGap.delete (low, length, buffer)
      val (buffer, searchList) = SearchList.build (buffer, dfa)

      val buffer = LineGap.goToIdx (low, buffer)
    in
      NormalFinish.buildTextAndClear
        (app, buffer, low, searchList, initialMsg, time)
    end

  fun deleteToNextMatch (app: app_type, count, time) =
    let
      val {cursorIdx, searchList, ...} = app
      val newCursorIdx =
        PersistentVector.nextMatch (cursorIdx, searchList, count)
    in
      if newCursorIdx = ~1 orelse newCursorIdx <= cursorIdx then
        NormalFinish.clearMode app
      else
        helpDeleteToMatch (app, cursorIdx, newCursorIdx, time)
    end

  fun deleteToPrevMatch (app: app_type, count, time) =
    let
      val {cursorIdx, searchList, ...} = app
      val newCursorIdx =
        PersistentVector.prevMatch (cursorIdx, searchList, count)
    in
      if newCursorIdx = ~1 orelse newCursorIdx >= cursorIdx then
        NormalFinish.clearMode app
      else
        helpDeleteToMatch (app, newCursorIdx, cursorIdx, time)
    end

  (* check if we are trying to delete from an empty buffer
   * or a buffer which consists of only one character which is \n *)
  fun canDeleteInsideOrAround (buffer, low, length) =
    not (length = 1 andalso LineGap.substring (low, 1, buffer) = "\n")

  fun deleteInsideWord (app: app_type, time) =
    let
      val {buffer, cursorIdx, dfa, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)

      val low = Cursor.prevWordStrict (buffer, cursorIdx, 1)
      val high = Cursor.endOfWordStrict (buffer, cursorIdx, 1) + 1

      val buffer = LineGap.goToIdx (high, buffer)
      val length = high - low
    in
      if canDeleteInsideOrAround (buffer, low, length) then
        let
          val buffer = LineGap.goToIdx (high, buffer)
          val length = high - low
          val initialMsg = Fn.initMsgs (low, length, buffer)

          val buffer = LineGap.delete (low, length, buffer)

          val (buffer, searchList) = SearchList.build (buffer, dfa)

          val buffer = LineGap.goToIdx (low, buffer)
        in
          NormalFinish.buildTextAndClear
            (app, buffer, low, searchList, initialMsg, time)
        end
      else
        app
    end

  fun deleteInsideWORD (app: app_type, time) =
    let
      val {buffer, cursorIdx, dfa, ...} = app
      val buffer = LineGap.goToIdx (cursorIdx, buffer)

      val low = Cursor.prevWORDStrict (buffer, cursorIdx, 1)
      val high = Cursor.endOfWORDStrict (buffer, cursorIdx, 1) + 1

      val buffer = LineGap.goToIdx (high, buffer)
      val length = high - low
    in
      if canDeleteInsideOrAround (buffer, low, length) then
        let
          val initialMsg = Fn.initMsgs (low, length, buffer)
          val buffer = LineGap.delete (low, length, buffer)
          val (buffer, searchList) = SearchList.build (buffer, dfa)

          val buffer = LineGap.goToIdx (low, buffer)
        in
          NormalFinish.buildTextAndClear
            (app, buffer, low, searchList, initialMsg, time)
        end
      else
        app
    end

  fun finishAfterDeleteInside (app: app_type, origLow, high, time) =
    if origLow = high then
      NormalFinish.clearMode app
    else
      let
        val {cursorIdx, buffer, dfa, ...} = app
        val low = origLow + 1
        val length = high - low

        val buffer = LineGap.goToIdx (high, buffer)
        val initialMsg = Fn.initMsgs (low, length, buffer)

        val buffer = LineGap.delete (low, length, buffer)
        val (buffer, searchList) = SearchList.build (buffer, dfa)

        val buffer = LineGap.goToIdx (origLow, buffer)
      in
        NormalFinish.buildTextAndClear
          (app, buffer, origLow, searchList, initialMsg, time)
      end

  fun deleteInsideChrOpen (app: app_type, chr, time) =
    let
      val {cursorIdx, buffer, ...} = app

      val start = cursorIdx + 1
      val buffer = LineGap.goToIdx (start, buffer)

      val origLow = Cursor.toPrevChr (buffer, start, chr)
      val buffer = LineGap.goToIdx (origLow, buffer)
      val high = Cursor.matchPair (buffer, origLow)
    in
      finishAfterDeleteInside (app, origLow, high, time)
    end

  fun deleteInsideChrClose (app: app_type, chr, time) =
    let
      val {cursorIdx, buffer, ...} = app

      val start = Int.max (cursorIdx - 1, 0)
      val buffer = LineGap.goToIdx (start, buffer)

      val high = Cursor.toNextChrNew (buffer, start, {findChr = chr, count = 1})
      val buffer = LineGap.goToIdx (high, buffer)
      val origLow = Cursor.matchPair (buffer, high)
    in
      finishAfterDeleteInside (app, origLow, high, time)
    end

  fun finishDeleteAroundChr (app, low, high, buffer, time) =
    let
      val length = high - low + 1
      val buffer = LineGap.goToIdx (high, buffer)
      val initialMsg = Fn.initMsgs (low, length, buffer)

      val buffer = LineGap.delete (low, length, buffer)
      val buffer = LineGap.goToIdx (low, buffer)
      val low =
        if Cursor.isCursorAtStartOfLine (buffer, low) then Int.max (low - 1, 0)
        else low
    in
      finishAfterDeletingBuffer (app, low, buffer, time, initialMsg)
    end

  fun deleteAroundChrOpen (app: app_type, chr, time) =
    let
      val {cursorIdx, buffer, ...} = app

      val start = cursorIdx + 1
      val buffer = LineGap.goToIdx (start, buffer)

      val low = Cursor.toPrevChr (buffer, start, chr)
      val buffer = LineGap.goToIdx (low, buffer)
      val high = Cursor.matchPair (buffer, low)
    in
      if low = high then NormalFinish.clearMode app
      else finishDeleteAroundChr (app, low, high, buffer, time)
    end

  fun deleteAroundChrClose (app: app_type, chr, time) =
    let
      val {cursorIdx, buffer, ...} = app

      val start = Int.max (cursorIdx - 1, 0)
      val buffer = LineGap.goToIdx (start, buffer)

      val high = Cursor.toNextChrNew (buffer, start, {findChr = chr, count = 1})
      val buffer = LineGap.goToIdx (high, buffer)
      val low = Cursor.matchPair (buffer, high)
    in
      if low = high then NormalFinish.clearMode app
      else finishDeleteAroundChr (app, low, high, buffer, time)
    end

  fun deletePair (app: app_type, time) =
    let
      val {cursorIdx, buffer, dfa, ...} = app
      val otherIdx = Cursor.matchPair (buffer, cursorIdx)
    in
      if otherIdx = cursorIdx then
        NormalFinish.clearMode app
      else
        let
          val low = Int.min (cursorIdx, otherIdx)
          val high = Int.max (cursorIdx, otherIdx)
          val length = high - low + 1

          val buffer = LineGap.goToIdx (high, buffer)
          val initialMsg = Fn.initMsgs (low, length, buffer)

          val buffer = LineGap.delete (low, length, buffer)
          val (buffer, searchList) = SearchList.build (buffer, dfa)

          val buffer = LineGap.goToIdx (low, buffer)

          val low =
            if Cursor.isCursorAtStartOfLine (buffer, low) then
              (* we may have deleted the last character of this current line,
               * and if we did, we have to move the cursor back by 1 *)
              Int.max (low - 1, 0)
            else
              low

          val buffer = LineGap.goToIdx (low, buffer)
        in
          NormalFinish.buildTextAndClear
            (app, buffer, low, searchList, initialMsg, time)
        end
    end
end