import ViE.UI

import ViE.BlikuAdapter

  let _ ← ViE.UI.render s

  let _ ← ViE.BlikuAdapter.render s

import ViE.UI

import ViE.BlikuAdapter

import ViE.UI.Overlay
import ViE.UI.Window
import ViE.UI.Render

-- Legacy renderer modules remain available for benchmarks and reference,
-- but the main app renders through `ViE.BlikuAdapter`.

-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3
import ViE.UI.Primitives
import ViE.UI.Search
import ViE.Terminal
namespace ViE.UI
open ViE
def renderWindow (state : EditorState) (windowId : Nat) (view : ViewState) (rect : Rect) : (Array String × EditorState) := Id.run do
  let r := rect.row
  let c := rect.col
  let h := rect.height
  let w := rect.width
  let workH := if h > 0 then h - 1 else 0
  let buf0 := getWorkspaceBuffer state view.bufferId
  let mut currentSt := state
  let mut winBuf : Array String := #[]
  let prefetchMargin := 20
  let totalLines := FileBuffer.lineCount buf0
  let startRow := if view.scrollRow.val > prefetchMargin then view.scrollRow.val - prefetchMargin else 0
  let endRow := min totalLines (view.scrollRow.val + workH + prefetchMargin)
  currentSt := prefetchSearchLineMatches currentSt buf0 startRow endRow
  for i in [0:workH] do
    let lineIdx : Row := ⟨view.scrollRow.val + i⟩
    let screenRow := r + i
    winBuf := winBuf.push (Terminal.moveCursorStr screenRow c)
    let buf := getWorkspaceBuffer currentSt view.bufferId
    if lineIdx.val < FileBuffer.lineCount buf then
      let lnWidth := if state.config.showLineNumbers then 4 else 0
      let availableWidth := if w > lnWidth then w - lnWidth else 0
      let cachedLine := buf.cache.find lineIdx
      let cachedRaw := buf.cache.findRaw lineIdx
      let cachedIdx := buf.cache.findIndex lineIdx
      let lineStr := cachedRaw.getD (getLineFromBuffer buf lineIdx |>.getD "")
      let lineIndex := cachedIdx.getD (ViE.Unicode.buildDisplayByteIndexWithTabStop lineStr state.config.tabStop)
      let (displayLine, nextSt) :=
        match cachedLine with
        | some (s, cachedScrollCol, cachedWidth) =>
            if cachedScrollCol == view.scrollCol.val && cachedWidth == availableWidth then
              (s, currentSt)
            else
              match getLineFromBuffer buf lineIdx with
              | some lineStr =>
                  let sub := ViE.Unicode.dropByDisplayWidthWithTabStop lineStr.toRawSubstring state.config.tabStop view.scrollCol.val
                  let dl := ViE.Unicode.takeByDisplayWidthWithTabStop sub state.config.tabStop availableWidth
                  let cache := match cachedRaw, cachedIdx with
                    | some raw, some _ =>
                        if raw == lineStr then
                          buf.cache
                        else
                          (buf.cache.updateIndex lineIdx (ViE.Unicode.buildDisplayByteIndexWithTabStop lineStr state.config.tabStop))
                    | _, _ =>
                        (buf.cache.updateIndex lineIdx (ViE.Unicode.buildDisplayByteIndexWithTabStop lineStr state.config.tabStop))
                  let cache := (cache.update lineIdx dl view.scrollCol.val availableWidth).updateRaw lineIdx lineStr
                  let updatedBuf := { buf with cache := cache }
                  let s' := currentSt.updateCurrentWorkspace fun ws =>
                    { ws with buffers := ws.buffers.map (fun (b : FileBuffer) => if b.id == buf.id then updatedBuf else b) }
                  (dl, s')
              | none => ("", currentSt)
        | none =>
            if let some lineStr := getLineFromBuffer buf lineIdx then
              let sub := ViE.Unicode.dropByDisplayWidthWithTabStop lineStr.toRawSubstring state.config.tabStop view.scrollCol.val
              let dl := ViE.Unicode.takeByDisplayWidthWithTabStop sub state.config.tabStop availableWidth
              let cache := match cachedRaw, cachedIdx with
                | some raw, some _ =>
                    if raw == lineStr then
                      buf.cache
                    else
                      (buf.cache.updateIndex lineIdx (ViE.Unicode.buildDisplayByteIndexWithTabStop lineStr state.config.tabStop))
                | _, _ =>
                    (buf.cache.updateIndex lineIdx (ViE.Unicode.buildDisplayByteIndexWithTabStop lineStr state.config.tabStop))
              let cache := (cache.update lineIdx dl view.scrollCol.val availableWidth).updateRaw lineIdx lineStr
              let updatedBuf := { buf with cache := cache }
              let s' := currentSt.updateCurrentWorkspace fun ws =>
                { ws with buffers := ws.buffers.map (fun (b : FileBuffer) => if b.id == buf.id then updatedBuf else b) }
              (dl, s')
            else
              ("", currentSt)
      currentSt := nextSt
      if state.config.showLineNumbers then
        winBuf := winBuf.push s!"{leftPad (toString (lineIdx.val + 1)) 3} "
      let isVisual := state.mode == Mode.visual || state.mode == Mode.visualLine || state.mode == Mode.visualBlock
      let selRange := if isVisual then state.selectionStart else none
      let (searchMatches, searchSt) := getLineSearchMatches currentSt buf.id lineIdx lineStr
      currentSt := searchSt
      let needsStyled := selRange.isSome || !searchMatches.isEmpty || !syntaxSpans.isEmpty
      if !needsStyled then
        winBuf := winBuf.push displayLine
      else
        let mut activeStyle : Option String := none
        let chars := displayLine.toList
        let mut dispIdx := 0
        let cursorByte :=
          if lineIdx == view.cursor.row then
            some (ViE.Unicode.displayColToByteOffsetFromIndex lineIndex view.cursor.col.val)
          else
            none
        let activeMatch := activeMatchRange searchMatches cursorByte
        for ch in chars do
          let chW := Unicode.charWidth ch
          let colVal := view.scrollCol.val + dispIdx
          let byteStart := ViE.Unicode.displayColToByteOffsetFromIndex lineIndex colVal
          let byteEnd := ViE.Unicode.displayColToByteOffsetFromIndex lineIndex (colVal + chW)
          let isSelected :=
            state.isInSelection lineIdx ⟨colVal⟩ ||
            (chW > 1 && state.isInSelection lineIdx ⟨colVal + 1⟩)
          let isMatched :=
            searchMatches.any (fun m => overlapsByteRange m byteStart byteEnd)
          let isActiveMatched :=
            match activeMatch with
            | some m => overlapsByteRange m byteStart byteEnd
            | none => false
          let desiredStyle : Option String :=
            if isSelected then
              some "\x1b[7m"
            else if isMatched then
              if isActiveMatched then
                some state.config.searchHighlightCursorStyle
              else
                some state.config.searchHighlightStyle
            else
              (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette syntaxSpans byteStart byteEnd).map
                (fun face => face.toAnsi)
          if desiredStyle != activeStyle then
            match activeStyle with
            | some _ => winBuf := winBuf.push "\x1b[0m"
            | none => pure ()
            match desiredStyle with
            | some stl => winBuf := winBuf.push stl
            | none => pure ()
            activeStyle := desiredStyle
          winBuf := winBuf.push ch.toString
          dispIdx := dispIdx + chW
        if activeStyle.isSome then
          winBuf := winBuf.push "\x1b[0m"
    else
      winBuf := winBuf.push state.config.emptyLineMarker
    winBuf := winBuf.push Terminal.clearLineStr
  let statusRow := r + workH
  let statusBuf := getWorkspaceBuffer currentSt view.bufferId
  winBuf := winBuf.push (Terminal.moveCursorStr statusRow c)
  let fileName := statusBuf.filename.getD "[No Name]"
  let modeStr := if windowId == currentSt.getCurrentWorkspace.activeWindowId then s!"-- {state.mode} --" else "--"
  let eolMark := if statusBuf.missingEol then " [noeol]" else ""
  let statusStr := s!"{modeStr} {fileName}{eolMark} [W:{windowId} B:{view.bufferId}] [{state.getCurrentWorkgroup.name}] {state.getCurrentWorkspace.name}"
  winBuf := winBuf.push state.config.statusBarStyle
  winBuf := winBuf.push statusStr.trimAscii.toString
  winBuf := winBuf.push Terminal.clearLineStr
  winBuf := winBuf.push state.config.resetStyle
  (winBuf, currentSt)
def renderFloatingWindow
    (st : EditorState)
    (view : ViewState)
    (rect : Rect)
    (borderFlags : FloatingWindowBorderFlags)
    : (Array String × Option (Nat × Nat)) := Id.run do
  let top := rect.row
  let left := rect.col
  let h := rect.height
  let w := rect.width
  let topBorderH := if borderFlags.top then 1 else 0
  let rightBorderW := if borderFlags.right then 1 else 0
  let bottomBorderH := if borderFlags.bottom then 1 else 0
  let leftBorderW := if borderFlags.left then 1 else 0
  let topBottomBorderH := topBorderH + bottomBorderH
  let sideBorderW := leftBorderW + rightBorderW
  if h < topBottomBorderH + 1 || w < sideBorderW + 1 then
    return (#[], none)
  let buf := getWorkspaceBuffer st view.bufferId
  let innerW := if w > sideBorderW then w - sideBorderW else 1
  let innerH := if h > topBottomBorderH then h - topBottomBorderH else 1
  let lnWidth := if st.config.showLineNumbers then 4 else 0
  let textW := if innerW > lnWidth then innerW - lnWidth else 1
  let repeatToken (token : String) (n : Nat) : String :=
    String.intercalate "" (List.replicate n token)
  let hBorder := if st.config.hSplitStr.isEmpty then "-" else st.config.hSplitStr
  let vBorder := if st.config.vSplitStr.isEmpty then "|" else st.config.vSplitStr
  let leftBorder := if borderFlags.left then vBorder else ""
  let rightBorder := if borderFlags.right then vBorder else ""
  let border := repeatToken hBorder w
  let mut out : Array String := #[]
  out := out.push st.config.resetStyle
  if borderFlags.top then
    out := out.push (Terminal.moveCursorStr top left)
    out := out.push border
  let isVisual := st.mode == Mode.visual || st.mode == Mode.visualLine || st.mode == Mode.visualBlock
  let hasSelection := isVisual && st.selectionStart.isSome
  for i in [0:innerH] do
    let lineIdx : Row := ⟨view.scrollRow.val + i⟩
    let raw := if lineIdx.val < FileBuffer.lineCount buf then getLineFromBuffer buf lineIdx |>.getD "" else ""
    let sub := ViE.Unicode.dropByDisplayWidthWithTabStop raw.toRawSubstring st.config.tabStop view.scrollCol.val
    let plainShown := ViE.Unicode.takeByDisplayWidthWithTabStop sub st.config.tabStop textW
    let shownW := Unicode.stringWidthWithTabStop plainShown st.config.tabStop
    let shown :=
      if hasSelection || !syntaxSpans.isEmpty then
        Id.run do
          let mut styled : Array String := #[]
          let mut activeStyle : Option String := none
          let mut dispOffset := 0
          for ch in plainShown.toList do
            let chW := Unicode.charWidth ch
            let selected :=
              st.isInSelection lineIdx ⟨dispCol⟩ ||
              (chW > 1 && st.isInSelection lineIdx ⟨dispCol + 1⟩)
            let desiredStyle :=
              if selected then
                some "\x1b[7m"
              else
                (Bliku.Tui.Syntax.faceForByteRange Bliku.Tui.Syntax.defaultPalette syntaxSpans byteStart byteEnd).map
                  (fun face => face.toAnsi)
            if desiredStyle != activeStyle then
              match activeStyle with
              | some _ => styled := styled.push st.config.resetStyle
              | none => pure ()
              match desiredStyle with
              | some stl => styled := styled.push stl
              | none => pure ()
              activeStyle := desiredStyle
            styled := styled.push ch.toString
            dispOffset := dispOffset + chW
          if activeStyle.isSome then
            styled := styled.push st.config.resetStyle
          return String.intercalate "" styled.toList
      else
        plainShown
    let padW := if shownW < textW then textW - shownW else 0
    let pad := "".pushn ' ' padW
    let withNo :=
      if st.config.showLineNumbers then
        s!"{leftPad (toString (lineIdx.val + 1)) 3} {shown}{pad}"
      else
        s!"{shown}{pad}"
    out := out.push (Terminal.moveCursorStr (top + topBorderH + i) left)
    out := out.push s!"{leftBorder}{withNo}{rightBorder}"
  if borderFlags.bottom then
    out := out.push (Terminal.moveCursorStr (top + h - 1) left)
    out := out.push border
  out := out.push st.config.resetStyle
  let cursorPos : Option (Nat × Nat) :=
    if view.cursor.row.val < view.scrollRow.val then
      none
    else
      let visRow := view.cursor.row.val - view.scrollRow.val
      if visRow < innerH then
        let visCol := if view.cursor.col.val >= view.scrollCol.val then view.cursor.col.val - view.scrollCol.val else 0
        let colOff := if st.config.showLineNumbers then 4 else 0
        let c := min (innerW - 1) (colOff + visCol)
        some (top + topBorderH + visRow, left + leftBorderW + c)
      else
        none
  return (out, cursorPos)
end ViE.UI
            let dispCol := view.scrollCol.val + dispOffset
            let byteStart := ViE.Unicode.displayColToByteOffsetFromIndex lineIndex dispCol
            let byteEnd := ViE.Unicode.displayColToByteOffsetFromIndex lineIndex (dispCol + chW)
    let lineIndex := ViE.Unicode.buildDisplayByteIndexWithTabStop raw st.config.tabStop
    let syntaxSpans := Bliku.Tui.Syntax.highlightLine buf.filename raw
      let syntaxSpans := Bliku.Tui.Syntax.highlightLine buf.filename lineStr
import Bliku.Tui.Syntax

import ViE.UI.Window
import ViE.UI.Overlay
import ViE.Terminal
namespace ViE.UI
open ViE
/-- Render the current editor state to the terminal. -/
def render (state : EditorState) : IO EditorState := do
  if !state.dirty then return state
  -- Start building the frame buffer
  let mut buffer : Array String := #[]
  buffer := buffer.push Terminal.hideCursorStr
  let (rows, cols) ← Terminal.getWindowSize
  let ws := state.getCurrentWorkspace
  let rec renderLayout (l : Layout) (st : EditorState) (r c h w : Nat) : (Array String × EditorState) := Id.run do
    match l with
    | Layout.window id view =>
      if st.getCurrentWorkspace.isFloatingWindow id then
        let mut blankBuf : Array String := #[]
        for i in [0:h] do
          blankBuf := blankBuf.push (Terminal.moveCursorStr (r + i) c)
          blankBuf := blankBuf.push ("".pushn ' ' w)
        return (blankBuf, st)
      renderWindow st id view { row := r, col := c, height := h, width := w }
    | Layout.hsplit left right ratio =>
      let leftW := (Float.ofNat w * ratio).toUInt64.toNat
      let (leftStr, st') := renderLayout left st r c h leftW
      -- Draw vertical separator
      let mut sepStr : Array String := #[]
      if w > leftW then
        let sepCol := c + leftW
        for i in [0:h] do
           sepStr := sepStr.push (Terminal.moveCursorStr (r + i) sepCol)
           sepStr := sepStr.push st.config.vSplitStr
      let (rightStr, st'') := renderLayout right st' r (c + leftW + 1) h (if w > leftW then w - leftW - 1 else 0)
      (leftStr ++ sepStr ++ rightStr, st'')
    | Layout.vsplit top bottom ratio =>
      let topH := (Float.ofNat h * ratio).toUInt64.toNat
      let (topStr, st') := renderLayout top st r c topH w
      -- Draw horizontal separator
      let mut sepStr : Array String := #[]
      if h > topH then
        let sepRow := r + topH
        sepStr := sepStr.push (Terminal.moveCursorStr sepRow c)
        for _ in [0:w] do
           sepStr := sepStr.push st.config.hSplitStr
      let (bottomStr, st'') := renderLayout bottom st' (r + topH + 1) c (if h > topH then h - topH - 1 else 0) w
      (topStr ++ sepStr ++ bottomStr, st'')
  let layoutH := rows - 1
  let baseLayout :=
    ws.getFloatingWindowIds.foldl (fun acc wid =>
      match acc with
      | some l => l.remove wid
      | none => none) (some ws.layout)
  if baseLayout.isNone then
    buffer := buffer.push Terminal.clearScreenStr
  buffer := buffer.push Terminal.homeCursorStr
  let (layoutStr, stateAfterLayout) :=
    match baseLayout with
    | some l => renderLayout l state 0 0 layoutH cols
    | none => (#[], state)
  buffer := buffer ++ layoutStr
  let wsAfterLayout := stateAfterLayout.getCurrentWorkspace
  let floatingViews := wsAfterLayout.getFloatingWindowIds.foldl (fun acc wid =>
    match wsAfterLayout.layout.findView wid with
    | some v => acc.push (wid, v)
    | none => acc) #[]
  let mut activeFloatingCursorPos : Option (Nat × Nat) := none
  for i in [0:floatingViews.size] do
    let (wid, view) := floatingViews[i]!
    match stateAfterLayout.getFloatingWindowBounds wid with
    | some (top, left, h, w) =>
      let borderFlags := stateAfterLayout.getFloatingWindowBorderFlags wid
      let (winBuf, cursorPos) := renderFloatingWindow stateAfterLayout view { row := top, col := left, height := h, width := w } borderFlags
      buffer := buffer ++ winBuf
      if wid == wsAfterLayout.activeWindowId then
        activeFloatingCursorPos := cursorPos
    | none => pure ()
  -- Global Status / Command Line
  buffer := buffer.push (Terminal.moveCursorStr (rows - 1) 0)
  let statusRight := renderStatusBar stateAfterLayout
  buffer := buffer.push statusRight
  buffer := buffer.push Terminal.clearLineStr
  let overlayToRender :=
    stateAfterLayout.floatingOverlay.orElse (fun _ => messageOverlayForState stateAfterLayout)
  if let some overlay := overlayToRender then
    buffer := buffer ++ renderFloatingOverlay rows cols stateAfterLayout.config.tabStop overlay
  -- Set Physical Cursor
  let rec getCursorPos (l : Layout) (r c h w : Nat) : Option (Nat × Nat) :=
    match l with
    | Layout.window id view =>
      if id == wsAfterLayout.activeWindowId then
         let workH := if h > 0 then h - 1 else 0
         let colOffset := if stateAfterLayout.config.showLineNumbers then 4 else 0
         let visualRow := view.cursor.row.val - view.scrollRow.val
         if visualRow >= 0 && visualRow < workH then
             if view.cursor.col.val < view.scrollCol.val then
               none
             else
               let visualCol := view.cursor.col.val - view.scrollCol.val
               if (visualCol + colOffset) < w then
                  some (r + visualRow, c + visualCol + colOffset)
               else none
         else none
      else none
    | Layout.hsplit left right ratio =>
      let leftW := (Float.ofNat w * ratio).toUInt64.toNat
      (getCursorPos left r c h leftW).orElse (fun _ => getCursorPos right r (c + leftW + 1) h (if w > leftW then w - leftW - 1 else 0))
    | Layout.vsplit top bottom ratio =>
      let topH := (Float.ofNat h * ratio).toUInt64.toNat
      (getCursorPos top r c topH w).orElse (fun _ => getCursorPos bottom (r + topH + 1) c (if h > topH then h - topH - 1 else 0) w)
  let overlayCursorPos : Option (Nat × Nat) :=
    match stateAfterLayout.floatingOverlay with
    | none => none
    | some overlay =>
        match computeFloatingOverlayLayout rows cols stateAfterLayout.config.tabStop overlay with
        | none => none
        | some layout =>
            let lines := if overlay.lines.isEmpty then #[""] else overlay.lines
            let maxRow := lines.size - 1
            let rowIdx := min overlay.cursorRow maxRow
            let line := lines[rowIdx]!
            let lineW := Unicode.stringWidthWithTabStop line stateAfterLayout.config.tabStop
            let colIdx := min overlay.cursorCol lineW
            let visRow := min rowIdx (layout.contentRows - 1)
            let visCol := min colIdx layout.innerWidth
            some (layout.top + 1 + layout.titleRows + visRow, layout.left + 2 + visCol)
  if stateAfterLayout.floatingOverlay.isSome && stateAfterLayout.mode != .command &&
     stateAfterLayout.mode != .searchForward && stateAfterLayout.mode != .searchBackward then
    buffer := buffer.push (
      match overlayCursorPos with
      | some (pr, pc) => Terminal.moveCursorStr pr pc
      | none => ""
    )
  else if wsAfterLayout.isFloatingWindow wsAfterLayout.activeWindowId &&
      stateAfterLayout.mode != .command && stateAfterLayout.mode != .searchForward && stateAfterLayout.mode != .searchBackward then
    buffer := buffer.push (
      match activeFloatingCursorPos with
      | some (pr, pc) => Terminal.moveCursorStr pr pc
      | none => ""
    )
  else
    buffer := buffer.push (
      match activeCursorPos with
      | some (pr, pc) => Terminal.moveCursorStr pr pc
      | none => ""
    )
  if stateAfterLayout.mode == .command then
     buffer := buffer.push (Terminal.moveCursorStr (rows - 1) (1 + stateAfterLayout.inputState.commandBuffer.length))
  if stateAfterLayout.mode == .searchForward || stateAfterLayout.mode == .searchBackward then
     buffer := buffer.push (Terminal.moveCursorStr (rows - 1) (1 + stateAfterLayout.inputState.commandBuffer.length))
  if stateAfterLayout.mode == .visual || stateAfterLayout.mode == .visualLine || stateAfterLayout.mode == .visualBlock then
    buffer := buffer.push Terminal.hideCursorStr
  else
    buffer := buffer.push Terminal.showCursorStr
  -- Output everything
  let finalStr := String.intercalate "" buffer.toList
  IO.print finalStr
  (← IO.getStdout).flush
  return stateAfterLayout
end ViE.UI
  let activeCursorPos := getCursorPos (baseLayout.getD wsAfterLayout.layout) 0 0 layoutH cols
  buffer := buffer ++ renderCompletionPopup rows cols stateAfterLayout activeCursorPos
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3

import ViE.UI.Primitives
import ViE.Terminal
import ViE.Color
namespace ViE.UI
open ViE
def shouldRenderMessageAsFloat (msg : String) : Bool :=
  let m := msg.trimAscii.toString
  if m.isEmpty then
    false
  else
    m.startsWith "Error" ||
    m.startsWith "Cannot" ||
    m.startsWith "Invalid" ||
    m.startsWith "Unknown" ||
    m.startsWith "No " ||
    m.startsWith "Empty " ||
    m.startsWith "Usage:" ||
    m.startsWith "failed" ||
    m.startsWith "Failed" ||
    m.contains "not found"
def renderStatusBar (state : EditorState) : String :=
  let plainMessage := state.message.trimAscii.toString
  let floatMessage := shouldRenderMessageAsFloat plainMessage
  if state.mode == .command then
    s!":{state.inputState.commandBuffer}"
  else if state.mode == .searchForward then
    s!"/{state.inputState.commandBuffer}"
  else if state.mode == .searchBackward then
    s!"?{state.inputState.commandBuffer}"
  else if floatMessage then
    ""
  else
    plainMessage
def messageOverlayForState (state : EditorState) : Option FloatingOverlay :=
  let plainMessage := state.message.trimAscii.toString
  let floatMessage := shouldRenderMessageAsFloat plainMessage
  if state.floatingOverlay.isNone &&
      state.mode != .command &&
      state.mode != .searchForward &&
      state.mode != .searchBackward &&
      floatMessage then
    if plainMessage.isEmpty then
      none
    else
      some {
        title := "Message"
        lines := (plainMessage.splitOn "\n").toArray
        maxWidth := 0
        cursorRow := 0
        cursorCol := 0
      }
  else
    none
structure FloatingOverlayLayout where
  top : Nat
  left : Nat
  innerWidth : Nat
  titleRows : Nat
  contentRows : Nat
  deriving Inhabited
def computeFloatingOverlayLayout (rows cols : Nat) (tabStop : Nat) (overlay : FloatingOverlay) : Option FloatingOverlayLayout := Id.run do
  let availableRows := if rows > 1 then rows - 1 else rows
  if cols < 8 || availableRows < 4 then
    return none
  let lines := if overlay.lines.isEmpty then #[""] else overlay.lines
  let titleText := if overlay.title.isEmpty then "" else s!"[{overlay.title}]"
  let titleRows := if titleText.isEmpty then 0 else 1
  let naturalWidthContent := lines.foldl (fun acc ln => max acc (Unicode.stringWidthWithTabStop ln tabStop)) 0
  let naturalWidth := max naturalWidthContent (Unicode.stringWidthWithTabStop titleText tabStop)
  let maxInnerWidth := if cols > 8 then cols - 8 else 1
  let targetWidth :=
    if overlay.maxWidth > 0 then
      overlay.maxWidth
    else
      naturalWidth
  let innerWidth := max 1 (min targetWidth maxInnerWidth)
  let maxContentRows :=
    if availableRows > titleRows + 2 then
      availableRows - titleRows - 2
    else
      0
  if maxContentRows == 0 then
    return none
  let naturalRows := lines.size
  let targetRows := naturalRows
  let contentRows := max 1 (min targetRows maxContentRows)
  let boxHeight := contentRows + titleRows + 2
  let boxWidth := innerWidth + 4
  let top := (availableRows - boxHeight) / 2
  let left := (cols - boxWidth) / 2
  return some {
    top := top
    left := left
    innerWidth := innerWidth
    titleRows := titleRows
    contentRows := contentRows
  }
def renderFloatingOverlay (rows cols : Nat) (tabStop : Nat) (overlay : FloatingOverlay) : Array String := Id.run do
  let some layout := computeFloatingOverlayLayout rows cols tabStop overlay | return #[]
  let lines := if overlay.lines.isEmpty then #[""] else overlay.lines
  let titleText := if overlay.title.isEmpty then "" else s!"[{overlay.title}]"
  let top := layout.top
  let left := layout.left
  let innerWidth := layout.innerWidth
  let titleRows := layout.titleRows
  let contentRows := layout.contentRows
  let border := "+" ++ "".pushn '-' (innerWidth + 2) ++ "+"
  let style := (ViE.Color.toBg .brightBlack) ++ (ViE.Color.toFg .white)
  let mut out : Array String := #[]
  out := out.push (Terminal.moveCursorStr top left)
  out := out.push style
  out := out.push border
  if titleRows == 1 then
    out := out.push (Terminal.moveCursorStr (top + 1) left)
    let clippedTitle := Unicode.takeByDisplayWidthWithTabStop titleText.toRawSubstring tabStop innerWidth
    let titleW := Unicode.stringWidthWithTabStop clippedTitle tabStop
    let titlePad := if titleW < innerWidth then "".pushn ' ' (innerWidth - titleW) else ""
    out := out.push s!"| {clippedTitle}{titlePad} |"
  for i in [0:contentRows] do
    let raw := lines[i]?.getD ""
    let clipped := Unicode.takeByDisplayWidthWithTabStop raw.toRawSubstring tabStop innerWidth
    let clippedW := Unicode.stringWidthWithTabStop clipped tabStop
    let pad := if clippedW < innerWidth then "".pushn ' ' (innerWidth - clippedW) else ""
    let row := top + 1 + titleRows + i
    out := out.push (Terminal.moveCursorStr row left)
    out := out.push s!"| {clipped}{pad} |"
  let bottom := top + contentRows + titleRows + 1
  out := out.push (Terminal.moveCursorStr bottom left)
  out := out.push border
  out := out.push ViE.Color.reset
  return out
end ViE.UI
private def repeatStr (s : String) (n : Nat) : String :=
  Id.run do
    let mut out := ""
    for _ in [0:n] do
      out := out ++ s
    return out
def renderCompletionPopup (rows cols : Nat) (state : EditorState) (cursorPos : Option (Nat × Nat)) : Array String := Id.run do
  let some popup := state.completionPopup | return #[]
  let some (cursorRow, cursorCol) := cursorPos | return #[]
  if popup.items.isEmpty then
    return #[]
  let availableRows := if rows > 1 then rows - 1 else rows
  if availableRows < 4 || cols < 8 then
    return #[]
  let visibleMax := min 8 popup.items.size
  let labels := popup.items.extract 0 visibleMax |>.map (fun it => it.label)
  let naturalW := labels.foldl (fun acc s => max acc (ViE.Unicode.stringWidthWithTabStop s state.config.tabStop)) 0
  let innerWidth := max 8 (min 48 naturalW)
  let boxWidth := innerWidth + 2
  let boxHeight := visibleMax + 2
  let placeBelow := cursorRow + 1 + boxHeight <= availableRows
  let top :=
    if placeBelow then
      cursorRow + 1
    else if cursorRow >= boxHeight then
      cursorRow - boxHeight
    else
      0
  let left0 := cursorCol
  let left := if left0 + boxWidth < cols then left0 else cols - boxWidth
  let hline := repeatStr state.config.hSplitStr innerWidth
  let borderTop := state.config.vSplitStr ++ hline ++ state.config.vSplitStr
  let borderBottom := borderTop
  let mut out : Array String := #[]
  out := out.push (Terminal.moveCursorStr top left)
  out := out.push borderTop
  let selected := if popup.selected < visibleMax then popup.selected else 0
  for i in [0:visibleMax] do
    let label := labels[i]!
    let clipped := ViE.Unicode.takeByDisplayWidthWithTabStop label.toRawSubstring state.config.tabStop innerWidth
    let clippedW := ViE.Unicode.stringWidthWithTabStop clipped state.config.tabStop
    let pad := if clippedW < innerWidth then "".pushn ' ' (innerWidth - clippedW) else ""
    let row := top + 1 + i
    out := out.push (Terminal.moveCursorStr row left)
    out := out.push state.config.vSplitStr
    if i == selected then
      out := out.push state.config.searchHighlightCursorStyle
      out := out.push clipped
      out := out.push pad
      out := out.push state.config.resetStyle
    else
      out := out.push clipped
      out := out.push pad
    out := out.push state.config.vSplitStr
  out := out.push (Terminal.moveCursorStr (top + boxHeight - 1) left)
  out := out.push borderBottom
  return out
-- SPDX-FileCopyrightText: 2026 Yuki Otsuka
--
-- SPDX-License-Identifier: BSD-3