📊 sniffert

scale_factor = total_pixel_area / total_size
item_area = item_size * scale_factor

# Example:
# Total area: 1000 pixels²
# Total size: 100 MB
# Item size: 25 MB
# Item area: 25 MB * (1000 / 100) = 250 pixels²

# Auto-scroll algorithm:
if selection.y < scroll_offset:
    scroll_offset = selection.y - 2  # Keep 2 lines margin
if selection.y > scroll_offset + viewport_height:
    scroll_offset = selection.y - viewport_height + 2

type :: rect
  integer :: x, y           ! Top-left corner (screen coords)
  integer :: width, height  ! Dimensions in characters
end type

type :: file_node
  character(len=:), allocatable :: name    ! Filename only
  character(len=:), allocatable :: path    ! Full filesystem path
  integer(int64) :: size                   ! Cumulative size in bytes
  logical :: is_directory                  ! Directory flag
  logical :: access_denied                 ! Permission denied flag
  type(rect) :: bounds                     ! Calculated layout bounds
  type(file_node), dimension(:), allocatable :: children
  integer :: num_children
end type

type :: selection_state
  integer :: depth                         ! Current depth in tree
  integer, dimension(MAX_DEPTH) :: indices ! Path of indices
  character(len=512) :: current_path       ! Filesystem path
end type

scan_directory(path, node, current_depth)
├─ Check if symlink (skip if yes)
├─ For directories:
│  ├─ Check depth limit (MAX_DEPTH = 100)
│  ├─ List directory entries
│  ├─ Filter entries (skip dots, vcs, build dirs)
│  ├─ Two-pass allocation:
│  │  ├─ Pass 1: Count valid children
│  │  └─ Pass 2: Allocate exact-size array
│  ├─ Recursively scan valid children
│  └─ Sum children sizes
└─ For files:
   └─ Query size via get_file_size()

# State structure:
selection_state:
  depth = 2
  indices = [1, 3, _, _, ...]  # Path: root → child[1] → grandchild[3]
  current_path = "/home/user/Downloads/videos"

# State transitions:
move_up()    → indices(depth) += 1 (if not at start)
move_down()  → indices(depth) -= 1 (if not at end)
move_right() → depth += 1; indices(depth) = 1 (first child)
move_left()  → depth -= 1 (if not at root)

squarify(remaining_nodes, remaining_bounds)
while nodes remain:
  1. Find best row:
     - Add items while aspect ratio improves
     - Stop when ratio degradation > 20%
     - Max 5 items per row
     - Min 10 chars width per box

  2. Calculate row area from item sizes

  3. Layout row:
     - If width >= height: Horizontal (fixed height)
       → layout_row_horizontal()
     - Else: Vertical (fixed width)
       → layout_row_vertical()

  4. Update remaining bounds, recurse

pure function aspect_ratio(width, height) result(ratio)
  ! Returns ratio normalized to >= 1.0
  ! Used to minimize maximum aspect ratio in rows

  if (width >= height) then
    ratio = real(width) / real(height)
  else
    ratio = real(height) / real(width)
  end if
end function

! Items are sorted by size (descending) before layout
! This produces better aspect ratios

# Byte-to-pixel scaling:
scale_factor = total_pixel_area / total_size

# Row height/width:
row_area = sum(item.size for item in row)
if horizontal_layout:
  row_height = row_area * scale_factor / bounds.width
else:
  row_width = row_area * scale_factor / bounds.height

# Item width within row:
item_width = item.size * scale_factor / row_height

# Constraints:
# - Minimum box width: 10 characters
# - Minimum box height: 3 lines
# - Last item fills remaining space (no gaps)

recursive subroutine scan_directory(path, node, depth)
  ! Constants
  integer, parameter :: MAX_DEPTH = 100
  integer, parameter :: MAX_FILES_PER_DIR = 10000

  ! Check depth limit
  if (depth > MAX_DEPTH) return

  ! Skip symlinks (prevents infinite loops)
  if (is_symlink(path)) return

  ! List directory entries
  entries = list_directory(path)

  ! Filter and recurse
  do i = 1, size(entries)
    if (should_skip(entries(i))) cycle
    call scan_directory(child_path, child_node, depth + 1)
  end do

  ! Calculate directory size as sum of children
  node%size = sum(node%children(:)%size)
end subroutine

! Pass 1: Count valid children
valid_count = 0
do i = 1, n_entries
  if (.not. should_skip(entries(i))) then
    valid_count = valid_count + 1
  end if
end do

! Allocate exact-size array
allocate(node%children(valid_count))

! Pass 2: Populate children
child_idx = 1
do i = 1, n_entries
  if (.not. should_skip(entries(i))) then
    node%children(child_idx) = create_child(entries(i))
    child_idx = child_idx + 1
  end if
end do

! Benefits:
! - No memory fragmentation
! - No over-allocation
! - Predictable memory usage

subroutine init_colors()
  call start_color()

  ! Pair 1: White on Blue (depth 0)
  call init_pair(1, COLOR_WHITE, COLOR_BLUE)

  ! Pair 2: Black on Green (depth 1)
  call init_pair(2, COLOR_BLACK, COLOR_GREEN)

  ! Pair 3: White on Red (depth 2)
  call init_pair(3, COLOR_WHITE, COLOR_RED)

  ! Pair 4: Black on Yellow (depth 3)
  call init_pair(4, COLOR_BLACK, COLOR_YELLOW)

  ! Pair 5: White on Magenta (depth 4)
  call init_pair(5, COLOR_WHITE, COLOR_MAGENTA)

  ! Pair 6: Black on Cyan (depth 5+)
  call init_pair(6, COLOR_BLACK, COLOR_CYAN)
end subroutine

! Usage: color_pair = mod(depth, 6) + 1

! Adjust for scroll offset
adjusted_y = node%bounds%y - scroll_offset

! Skip completely off-screen leaf nodes
if (node%is_file) then
  if (adjusted_y + node%bounds%height < 0) return
  if (adjusted_y > max_y) return
end if

! For directories: always recurse (children may be visible)
! But clip the box itself if partially off-screen

! Top clipping:
if (adjusted_y < 0) then
  new_height = node%bounds%height + adjusted_y
  adjusted_y = 0
end if

! Bottom clipping:
if (adjusted_y + new_height > max_y - 1) then
  new_height = max_y - 1 - adjusted_y
end if

// C helper functions
int64_t get_size_helper(const char* path) {
  struct stat st;
  if (stat(path, &st) != 0) return -1;
  return st.st_size;
}

int is_dir_helper(const char* path) {
  struct stat st;
  if (stat(path, &st) != 0) return 0;
  return S_ISDIR(st.st_mode);
}

int is_link_helper(const char* path) {
  struct stat st;
  if (lstat(path, &st) != 0) return 0;
  return S_ISLNK(st.st_mode);
}

interface
  function get_size_helper(path) bind(c, name='get_size_helper')
    use, intrinsic :: iso_c_binding
    character(kind=c_char), intent(in) :: path(*)
    integer(c_int64_t) :: get_size_helper
  end function
end interface