/-- Cached terminal size to avoid spawning `stty` every frame. -/
initialize terminalSizeCache : IO.Ref (Option (Nat × Nat)) ← IO.mkRef none
private def parseEnvSize : IO (Option (Nat × Nat)) := do
  let rows? ← IO.getEnv "LINES"
  let cols? ← IO.getEnv "COLUMNS"
  match (rows?.bind String.toNat?, cols?.bind String.toNat?) with
  | (some r, some c) =>
      if r > 0 && c > 0 then
        return some (r, c)
      else
        return none
  | _ => return none

  let out ← IO.Process.run { cmd := "stty", args := #["-F", "/dev/tty", "size"] }
  let parts := out.trimAscii.toString.splitOn " "
  match parts with
  | [rows, cols] => pure (rows.toNat!, cols.toNat!)
  | _ => pure (24, 80)

  if let some sz ← terminalSizeCache.get then
    return sz
  if let some sz ← parseEnvSize then
    terminalSizeCache.set (some sz)
    return sz
  try
    let out ← IO.Process.run { cmd := "stty", args := #["-F", "/dev/tty", "size"] }
    let parts := out.trimAscii.toString.splitOn " "
    let sz := match parts with
      | [rows, cols] =>
          match (rows.toNat?, cols.toNat?) with
          | (some r, some c) =>
              if r > 0 && c > 0 then (r, c) else (24, 80)
          | _ => (24, 80)
      | _ => (24, 80)
    terminalSizeCache.set (some sz)
    return sz
  catch _ =>
    return (24, 80)

namespace Bliku.Tui.Tabs
/-- Generic tab state. -/
structure State where
  active : Nat := 0
  total : Nat := 0
  deriving Inhabited, Repr
def State.clamp (s : State) : State :=
  let maxIdx := if s.total == 0 then 0 else s.total - 1
  { s with active := min s.active maxIdx }
def State.next (s : State) : State :=
  let maxIdx := if s.total == 0 then 0 else s.total - 1
  { s with active := min (s.active + 1) maxIdx } |>.clamp
def State.prev (s : State) : State :=
  { s with active := if s.active > 0 then s.active - 1 else 0 } |>.clamp
end Bliku.Tui.Tabs

namespace Bliku.Tui.Cursor
/-- Scroll/selection state for list-like UIs. -/
structure State where
  selected : Nat := 0
  scroll : Nat := 0
  totalRows : Nat := 0
  viewportRows : Nat := 20
  margin : Nat := 3
  deriving Inhabited, Repr
def autoScrollRow
    (selectedRow scrollRow totalRows : Nat)
    (viewportRows : Nat := 20)
    (margin : Nat := 3) : Nat :=
  if totalRows == 0 || viewportRows == 0 then
    0
  else
    let maxScroll := totalRows - 1
    let lowBound := scrollRow + margin
    let highBound := scrollRow + (viewportRows - 1 - min margin (viewportRows - 1))
    if selectedRow < lowBound then
      min (selectedRow - margin) maxScroll
    else if selectedRow > highBound then
      let wanted := selectedRow - (viewportRows - 1 - min margin (viewportRows - 1))
      min wanted maxScroll
    else
      min scrollRow maxScroll
def State.clamp (s : State) : State :=
  let maxIdx := if s.totalRows == 0 then 0 else s.totalRows - 1
  let selected := min s.selected maxIdx
  let scroll := autoScrollRow selected s.scroll s.totalRows s.viewportRows s.margin
  { s with selected := selected, scroll := scroll }
def State.moveDown (s : State) : State :=
  let maxIdx := if s.totalRows == 0 then 0 else s.totalRows - 1
  { s with selected := min (s.selected + 1) maxIdx } |>.clamp
def State.moveUp (s : State) : State :=
  { s with selected := if s.selected > 0 then s.selected - 1 else 0 } |>.clamp
def State.moveTop (s : State) : State :=
  { s with selected := 0 } |>.clamp
def State.moveBottom (s : State) : State :=
  let maxIdx := if s.totalRows == 0 then 0 else s.totalRows - 1
  { s with selected := maxIdx } |>.clamp
end Bliku.Tui.Cursor

namespace Bliku.Tui.Collapsible
/-- Collapsible section state indexed by Nat key. -/
structure State where
  collapsed : Array Nat := #[]
  deriving Inhabited, Repr
def State.isCollapsed (s : State) (k : Nat) : Bool :=
  s.collapsed.contains k
def State.toggle (s : State) (k : Nat) : State :=
  match s.collapsed.findIdx? (fun x => x == k) with
  | some _ => { s with collapsed := s.collapsed.filter (fun x => x != k) }
  | none => { s with collapsed := s.collapsed.push k }
end Bliku.Tui.Collapsible