-- Active window height. Reserve 1 line for status bar?
  -- UI logic reserves 1 for status bar in split rendering.
  let linesInView := if h > 1 then h - 1 else 1

  -- Active window height already excludes the global status line.
  let linesInView := if h > 0 then h else 1

      let newScrollRow : Row := ⟨sRow.val + linesInView - 1⟩

      let newScrollRow : Row := ⟨cursor.row.val - (linesInView - 1)⟩

          let s' := { s with inputState := { s.inputState with commandBuffer := s!"ee {parentPath}" } }
          ViE.Command.executeCommand commands s'

          ViE.Feature.openExplorerWithPreview s parentPath explorer.previewWindowId explorer.previewBufferId

def getSelectedIndex (state : EditorState) (explorer : ExplorerState) : Option Nat :=
  let cursor := state.getCursor
  if cursor.row < 2 then
    none
  else
    let idx := cursor.row - 2
    if idx.val < explorer.entries.length then
      some idx.val
    else
      none
def buildWorkspacePreviewLines (ws : WorkspaceState) : List String :=
  let header := [s!"Workspace: {ws.name}", ""]
  let entries := ws.buffers.map fun b =>
    match b.filename with
    | some name => name
    | none => s!"[Untitled:{b.id}]"
  if entries.isEmpty then
    header ++ ["(no buffers)"]
  else
    header ++ entries
def buildWorkgroupPreviewLines (wg : WorkgroupState) : List String :=
  let header := [s!"Workgroup: {wg.name}", ""]
  let entries := wg.workspaces.toList.map (fun ws => ws.name)
  if entries.isEmpty then
    header ++ ["(no workspaces)"]
  else
    header ++ entries
def ensurePreviewTextBuffer (state : EditorState) (explorer : ExplorerState) (title : String) (lines : List String) : (EditorState × Nat) :=
  let content : TextBuffer := if lines.isEmpty then #[#[]] else lines.toArray.map stringToLine
  let buf := { ViE.Buffer.fileBufferFromTextBuffer 0 (some s!"preview://{title}") content with dirty := false }
  match explorer.previewBufferId with
  | some pid =>
    let ws := state.getCurrentWorkspace
    if ws.buffers.any (fun b => b.id == pid) then
      let updated := { buf with id := pid }
      let s' := state.updateCurrentWorkspace fun ws =>
        { ws with buffers := ws.buffers.map (fun b => if b.id == pid then updated else b) }
      (s', pid)
    else
      let (pid, s') := ViE.Buffer.addBuffer state buf
      (s', pid)
  | none =>
    let (pid, s') := ViE.Buffer.addBuffer state buf
    (s', pid)
def getPreviewWorkspace (state : EditorState) (explorer : ExplorerState) : WorkspaceState :=
  let wg := state.getCurrentWorkgroup
  match getSelectedIndex state explorer with
  | some idx =>
    if idx >= 2 then
      let real := idx - 2
      if h : real < wg.workspaces.size then
        wg.workspaces[real]!
      else
        state.getCurrentWorkspace
    else
      state.getCurrentWorkspace
  | none => state.getCurrentWorkspace

def getPreviewWorkgroup (state : EditorState) (explorer : ExplorerState) : WorkgroupState :=
  match getSelectedIndex state explorer with
  | some idx =>
    if idx >= 2 then
      let real := idx - 2
      if h : real < state.workgroups.size then
        state.workgroups[real]!
      else
        state.getCurrentWorkgroup
    else
      state.getCurrentWorkgroup
  | none => state.getCurrentWorkgroup

    if explorer.mode != .files then
      return state

      match getSelectedEntry state explorer with
      | none => return state
      | some entry =>
        if entry.isDirectory then
          return state
        else
          let (s1, previewBufId) ← ensurePreviewBuffer state explorer entry

      match explorer.mode with
      | .files =>
        match getSelectedEntry state explorer with
        | none => return state
        | some entry =>
          if entry.isDirectory then
            return state
          else
            let (s1, previewBufId) ← ensurePreviewBuffer state explorer entry
            let s2 := s1.updateCurrentWorkspace fun ws =>
              { ws with layout := ws.layout.updateView previewWinId (fun v =>
                { v with bufferId := previewBufId, cursor := Point.zero, scrollRow := 0, scrollCol := 0 }) }
            let s3 := updateExplorerState s2 bufId (fun ex => { ex with previewBufferId := some previewBufId })
            return s3
      | .workspaces =>
          let ws := getPreviewWorkspace state explorer
          let lines := buildWorkspacePreviewLines ws
          let (s1, previewBufId) := ensurePreviewTextBuffer state explorer ws.name lines
          let s2 := s1.updateCurrentWorkspace fun ws =>
            { ws with layout := ws.layout.updateView previewWinId (fun v =>
              { v with bufferId := previewBufId, cursor := Point.zero, scrollRow := 0, scrollCol := 0 }) }
          let s3 := updateExplorerState s2 bufId (fun ex => { ex with previewBufferId := some previewBufId })
          return s3
      | .workgroups =>
          let wg := getPreviewWorkgroup state explorer
          let lines := buildWorkgroupPreviewLines wg
          let (s1, previewBufId) := ensurePreviewTextBuffer state explorer wg.name lines

  if explorer.mode != .files then
    return state

    let entryOpt := getSelectedEntry s1 explorer

      match entryOpt with
      | some entry =>
        if entry.isDirectory then

      match explorer.mode with
      | .files =>
        let entryOpt := getSelectedEntry s1 explorer
        match entryOpt with
        | some entry =>
          if entry.isDirectory then
            let content : TextBuffer := #[#[]]
            let buf := { ViE.Buffer.fileBufferFromTextBuffer 0 (some "preview://") content with dirty := false }
            let (pid, s2) := ViE.Buffer.addBuffer s1 buf
            pure (s2, pid)
          else
            ensurePreviewBuffer s1 explorer entry
        | none =>

        else
          ensurePreviewBuffer s1 explorer entry
      | none =>
        let content : TextBuffer := #[#[]]
        let buf := { ViE.Buffer.fileBufferFromTextBuffer 0 (some "preview://") content with dirty := false }
        let (pid, s2) := ViE.Buffer.addBuffer s1 buf

      | .workspaces =>
        let ws := getPreviewWorkspace s1 explorer
        let lines := buildWorkspacePreviewLines ws
        let (s2, pid) := ensurePreviewTextBuffer s1 explorer ws.name lines
        pure (s2, pid)
      | .workgroups =>
        let wg := getPreviewWorkgroup s1 explorer
        let lines := buildWorkgroupPreviewLines wg
        let (s2, pid) := ensurePreviewTextBuffer s1 explorer wg.name lines

    if explorer.mode != .files then
      return { state with message := "Preview is only available in file explorer" }

      match getSelectedEntry state explorer with
      | none => return { state with message := "Preview: no selection" }
      | some entry =>
        if entry.isDirectory then
          return { state with message := "Preview: directory" }
        else

      match explorer.mode with
      | .files =>
        match getSelectedEntry state explorer with
        | none => return { state with message := "Preview: no selection" }
        | some entry =>
          if entry.isDirectory then
            return { state with message := "Preview: directory" }
          else
            let ws := state.getCurrentWorkspace
            let previewWinId := ws.nextWindowId
            let s1 := ViE.Window.splitWindow state false
            let (s2, previewBufId) ← ensurePreviewBuffer s1 explorer entry
            let s3 := s2.updateCurrentWorkspace fun ws =>
              { ws with layout := ws.layout.updateView previewWinId (fun v =>
                { v with bufferId := previewBufId, cursor := Point.zero, scrollRow := 0, scrollCol := 0 }) }
            let s4 := updateExplorerState s3 bufId (fun ex => { ex with previewWindowId := some previewWinId, previewBufferId := some previewBufId })
            return { s4 with message := "Preview opened" }
      | .workspaces =>

          let (s2, previewBufId) ← ensurePreviewBuffer s1 explorer entry

          let previewWs := getPreviewWorkspace s1 explorer
          let lines := buildWorkspacePreviewLines previewWs
          let (s2, previewBufId) := ensurePreviewTextBuffer s1 explorer previewWs.name lines

          return { s4 with message := s!"Preview: {entry.name}" }

          return { s4 with message := "Preview opened" }
      | .workgroups =>
          let ws := state.getCurrentWorkspace
          let previewWinId := ws.nextWindowId
          let s1 := ViE.Window.splitWindow state false
          let previewWg := getPreviewWorkgroup s1 explorer
          let lines := buildWorkgroupPreviewLines previewWg
          let (s2, previewBufId) := ensurePreviewTextBuffer s1 explorer previewWg.name lines
          let s3 := s2.updateCurrentWorkspace fun ws =>
            { ws with layout := ws.layout.updateView previewWinId (fun v =>
              { v with bufferId := previewBufId, cursor := Point.zero, scrollRow := 0, scrollCol := 0 }) }
          let s4 := updateExplorerState s3 bufId (fun ex => { ex with previewWindowId := some previewWinId, previewBufferId := some previewBufId })
          return { s4 with message := "Preview opened" }

  return { s''' with message := s!"Workspace Explorer: {wg.name}" }

  let s'''' := { s''' with message := s!"Workspace Explorer: {wg.name}" }
  return (← openExplorerDefaultPreview s'''' bufferId explorerState)

  return { s''' with message := "Workgroup Explorer" }

  let s'''' := { s''' with message := "Workgroup Explorer" }
  return (← openExplorerDefaultPreview s'''' bufferId explorerState)

import Test.Scroll

  Test.Scroll.test

set_option maxRecDepth 2048

  IO.println "Starting Workspace Explorer Preview Test..."
  let bufP1 : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 1 (some "/tmp/a.txt") #[stringToLine "A"]
  let bufP2 : FileBuffer := ViE.Buffer.fileBufferFromTextBuffer 2 (some "/tmp/b.txt") #[stringToLine "B"]
  let wsP : WorkspaceState := {
    name := "WS-P"
    rootPath := none
    buffers := [bufP1, bufP2]
    nextBufferId := 3
    layout := .window 0 { initialView with bufferId := 1 }
    activeWindowId := 0
    nextWindowId := 1
  }
  let s12a := addWorkspace s12 wsP
  let wgP := s12a.getCurrentWorkgroup
  let idxP := if wgP.workspaces.size == 0 then 0 else wgP.workspaces.size - 1
  let s12b := switchWorkspace s12a idxP
  let s12c ← ViE.Feature.openWorkspaceExplorer s12b
  let explorerOpt := s12c.explorers.find? (fun (id, _) => id == s12c.getActiveBuffer.id)
  match explorerOpt with
  | none => throw (IO.userError "Workspace explorer not registered")
  | some (_, explorer) =>
    assertEqual "Workspace explorer preview window exists" true explorer.previewWindowId.isSome
    let previewWinId := explorer.previewWindowId.get!
    let wsPrev := s12c.getCurrentWorkspace
    let previewView := wsPrev.layout.findView previewWinId |>.getD initialView
    let previewBuf := wsPrev.buffers.find? (fun b => b.id == previewView.bufferId) |>.getD initialBuffer
    let previewText := previewBuf.table.toString
    assertEqual "Workspace preview includes a.txt" true (previewText.contains "/tmp/a.txt")
    assertEqual "Workspace preview includes b.txt" true (previewText.contains "/tmp/b.txt")

  let explorerOpt := s2.explorers.find? (fun (id, _) => id == s2.getActiveBuffer.id)
  match explorerOpt with
  | none => throw (IO.userError "Workgroup explorer not registered")
  | some (_, explorer) =>
    assertEqual "Workgroup explorer preview window exists" true explorer.previewWindowId.isSome
    let previewWinId := explorer.previewWindowId.get!
    let wsPrev := s2.getCurrentWorkspace
    let previewView := wsPrev.layout.findView previewWinId |>.getD initialView
    let previewBuf := wsPrev.buffers.find? (fun b => b.id == previewView.bufferId) |>.getD initialBuffer
    let previewText := previewBuf.table.toString
    assertEqual "Workgroup preview includes Project A" true (previewText.contains "Project A")
    assertEqual "Workgroup preview includes Project B" true (previewText.contains "Project B")

import ViE.Window.Actions
import ViE.State
import ViE.Types
import ViE.Config
namespace Test.Scroll
open ViE
def assert (msg : String) (cond : Bool) : IO Unit := do
  if cond then
    IO.println s!"[PASS] {msg}"
  else
    IO.println s!"[FAIL] {msg}"
    throw (IO.userError s!"Assertion failed: {msg}")
def test : IO Unit := do
  let config := ViE.defaultConfig
  let state := ViE.initialState
  -- Set window size (e.g., 10 lines)
  let state := { state with windowHeight := 10, windowWidth := 80 }
  -- Move cursor to line 100
  let state := state.setCursor { row := ⟨100⟩, col := ⟨0⟩ }
  -- Enforce scroll
  let state := ViE.Window.enforceScroll state
  let (sRow, _) := state.getScroll
  IO.println s!"Cursor Row: 100, Scroll Row: {sRow.val}, Window Height: 10"
  -- View range is [sRow, sRow + 9] (10 lines)
  -- We expect 100 to be in [sRow, sRow + 9]
  -- So sRow <= 100 AND 100 < sRow + 10  => sRow > 90
  let visible := sRow.val <= 100 && 100 < sRow.val + 10
  assert "Cursor is visible" visible
  -- Upper boundary: cursor above scroll should pull scroll up
  let state2 := { state with
    mode := .normal
  }
  let state2 := state2.setScroll ⟨10⟩ ⟨0⟩
  let state2 := state2.setCursor { row := ⟨2⟩, col := ⟨0⟩ }
  let state2 := ViE.Window.enforceScroll state2
  let (sRow2, _) := state2.getScroll
  assert "Scroll moves up to include cursor" (sRow2.val == 2)
  -- Horizontal right boundary: cursor beyond view should scroll right
  let state3 := { state with windowHeight := 5, windowWidth := 20 }
  let state3 := state3.setScroll ⟨0⟩ ⟨0⟩
  let state3 := state3.setCursor { row := ⟨0⟩, col := ⟨30⟩ }
  let state3 := ViE.Window.enforceScroll state3
  let (_, sCol3) := state3.getScroll
  let colsInView := 20 -- showLineNumbers is false by default
  let visible3 := sCol3.val <= 30 && 30 < sCol3.val + colsInView
  assert "Horizontal scroll keeps cursor visible" visible3
  -- Horizontal left boundary: cursor before scroll should pull scroll left
  let state4 := { state with windowHeight := 5, windowWidth := 20 }
  let state4 := state4.setScroll ⟨0⟩ ⟨10⟩
  let state4 := state4.setCursor { row := ⟨0⟩, col := ⟨2⟩ }
  let state4 := ViE.Window.enforceScroll state4
  let (_, sCol4) := state4.getScroll
  assert "Horizontal scroll moves left to include cursor" (sCol4.val == 2)