tui.go

// SPDX-License-Identifier: MIT

package main

import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"time"

	"github.com/boyter/cs/v3/pkg/common"
	"github.com/boyter/cs/v3/pkg/ranker"
	"github.com/boyter/cs/v3/pkg/snippet"
	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	"github.com/muesli/termenv"
)

// searchResult represents a single search result
type searchResult struct {
	Filename       string
	Location       string
	Score          float64
	Snippets       []snippet.Snippet      // free-text snippet mode
	LineClusters   [][]snippet.LineResult // lines/grep mode (grep = single cluster)
	SnippetIdx     int                    // shared cycle index across Snippets / LineClusters
	Language       string
	TotalLines     int64
	Code           int64
	Comment        int64
	Blank          int64
	Complexity     int64
	DuplicateCount int
	MatchLocations map[string][][]int // absolute byte positions in file
	Prose          bool               // true for prose/text files (skip syntax highlighting)
}

// snippetCount returns the number of cyclable "snippets" — free-text snippets
// in snippet mode, or line clusters in lines/grep mode.
func (r *searchResult) snippetCount() int {
	if len(r.Snippets) > 0 {
		return len(r.Snippets)
	}
	return len(r.LineClusters)
}

// activeIdx clamps SnippetIdx into a valid range.
func (r *searchResult) activeIdx() int {
	n := r.snippetCount()
	if n == 0 {
		return 0
	}
	if r.SnippetIdx < 0 {
		return 0
	}
	if r.SnippetIdx >= n {
		return n - 1
	}
	return r.SnippetIdx
}

// activeSnippet returns the currently displayed free-text snippet, or nil.
func (r *searchResult) activeSnippet() *snippet.Snippet {
	if len(r.Snippets) == 0 {
		return nil
	}
	return &r.Snippets[r.activeIdx()]
}

// activeCluster returns the currently displayed cluster of LineResult, or nil.
func (r *searchResult) activeCluster() []snippet.LineResult {
	if len(r.LineClusters) == 0 {
		return nil
	}
	return r.LineClusters[r.activeIdx()]
}

// activeLineRange returns the "start-end" range string for the currently
// displayed snippet or cluster.
func (r *searchResult) activeLineRange() string {
	if s := r.activeSnippet(); s != nil {
		return fmt.Sprintf("%d-%d", s.LineStart, s.LineEnd)
	}
	if c := r.activeCluster(); len(c) > 0 {
		return fmt.Sprintf("%d-%d", c[0].LineNumber, c[len(c)-1].LineNumber)
	}
	return ""
}

// debounceTickMsg is sent after the debounce delay to trigger a search
type debounceTickMsg struct {
	seq   int
	query string
}

// searchResultsMsg delivers incremental search results from the search goroutine
type searchResultsMsg struct {
	seq       int
	results   []searchResult
	fileJobs  []*common.FileJob
	done      bool // true = search complete
	total     int  // total files scanned so far
	textTotal int  // non-binary, successfully read files (for BM25 ranking)
}

// Styles
var (
	titleStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("5")) // fuchsia/magenta

	selectedTitleStyle = lipgloss.NewStyle().
				Foreground(lipgloss.Color("5")).
				Bold(true)

	snippetStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("252"))

	selectedSnippetStyle = lipgloss.NewStyle().
				Foreground(lipgloss.Color("252"))

	matchStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("1")). // red
			Bold(true)

	selectedMatchStyle = lipgloss.NewStyle().
				Foreground(lipgloss.Color("1")).
				Bold(true)

	statusStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("243"))

	inputLabelStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("7"))

	snippetLabelStyle = lipgloss.NewStyle().
				Foreground(lipgloss.Color("243"))

	selectedIndicator = lipgloss.NewStyle().
				Foreground(lipgloss.Color("5")).
				SetString("▎")

	navIndicator = lipgloss.NewStyle().
			Foreground(lipgloss.Color("13")). // bright magenta — signals snippet-cycling focus
			Bold(true).
			SetString("▌")

	snippetCounterStyle = lipgloss.NewStyle().
				Foreground(lipgloss.Color("6")). // cyan — visible without screaming
				Italic(true)

	snippetCounterActiveStyle = lipgloss.NewStyle().
					Foreground(lipgloss.Color("13")). // bright magenta when actively cycling
					Bold(true)
)

type model struct {
	cfg           *Config
	searchInput   textinput.Model
	snippetInput  textinput.Model
	focusIndex    int // 0=search, 1=snippet-length, 2=result-nav (snippet cycling)
	results       []searchResult
	fileJobs      []*common.FileJob
	selectedIndex int
	scrollOffset  int
	windowHeight  int
	windowWidth   int
	chosen        string // set on Enter, printed after exit

	searchSeq     int                   // monotonic counter, incremented on every text change
	searching     bool                  // true while search is in flight
	searchCancel  context.CancelFunc    // cancels in-flight search; nil if none
	searchResults chan searchResultsMsg // channel from search goroutine
	lastQuery     string                // query that produced current results
	errMsg        string                // transient error message shown in status line
	fileCount     int                   // total files scanned (for status line)
	textFileCount int                   // non-binary, successfully read files (for BM25 ranking)
	snippetMode   string                // "snippet" or "lines"
	searchCache   *SearchCache          // caches file locations across progressive queries

	// File viewer overlay state
	viewing         bool               // true when viewer is open
	viewLines       []string           // lines of the viewed file
	viewScroll      int                // scroll offset (line index of top of viewport)
	viewFilename    string             // display filename
	viewLocation    string             // full file path (for Enter-to-select)
	viewLanguage    string             // language for title
	viewLineRange   string             // original match line range
	viewMatchLocs   map[string][][]int // absolute byte match positions
	viewLineOffsets []int              // byte offset where each line starts
	viewStartLine   int                // line to initially center on
	viewProse       bool               // true if viewed file is prose (skip syntax highlighting)
}

func initialModel(cfg *Config) model {
	switch cfg.Color {
	case "always":
		lipgloss.SetColorProfile(termenv.ANSI256)
	case "never":
		lipgloss.SetColorProfile(termenv.Ascii)
	}

	si := textinput.New()
	si.Placeholder = "search query..."
	si.Prompt = "> "
	si.Focus()
	si.CharLimit = 256

	sn := textinput.New()
	sn.Placeholder = ""
	sn.Prompt = ""
	sn.SetValue(fmt.Sprintf("%d", cfg.SnippetLength))
	sn.CharLimit = 5
	sn.Width = 5

	return model{
		cfg:          cfg,
		searchInput:  si,
		snippetInput: sn,
		focusIndex:   0,
		snippetMode:  cfg.SnippetMode,
		searchCache:  NewSearchCache(),
	}
}

func (m model) Init() tea.Cmd {
	return tea.Batch(tea.EnterAltScreen, textinput.Blink)
}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	var cmds []tea.Cmd

	switch msg := msg.(type) {
	case tea.WindowSizeMsg:
		m.windowHeight = msg.Height
		m.windowWidth = msg.Width
		m.clampScroll()
		return m, nil

	case debounceTickMsg:
		if msg.seq != m.searchSeq {
			return m, nil // stale tick, user kept typing
		}
		if m.searchCancel != nil {
			m.searchCancel() // cancel previous search
		}

		query := strings.TrimSpace(msg.query)
		if query == "" {
			m.results = nil
			m.fileJobs = nil
			m.searching = false
			m.fileCount = 0
			return m, nil
		}

		// Parse snippet length from input
		snippetLen := 300
		if v := m.snippetInput.Value(); v != "" {
			fmt.Sscanf(v, "%d", &snippetLen)
		}

		ctx, cancel := context.WithCancel(context.Background())
		m.searchCancel = cancel
		m.searching = true
		m.results = nil
		m.fileJobs = nil
		m.selectedIndex = 0
		m.scrollOffset = 0
		m.fileCount = 0
		ch := make(chan searchResultsMsg, 1)
		m.searchResults = ch
		go realSearch(ctx, m.cfg, m.searchSeq, query, snippetLen, m.snippetMode, m.searchCache, ch)
		return m, listenForResults(ch)

	case searchResultsMsg:
		if msg.seq != m.searchSeq {
			return m, nil // stale results from old search
		}

		m.results = append(m.results, msg.results...)
		m.fileJobs = append(m.fileJobs, msg.fileJobs...)
		m.fileCount = msg.total
		m.textFileCount = msg.textTotal

		if msg.done {
			m.searching = false
			m.searchCancel = nil
			m.lastQuery = m.searchInput.Value()

			// Rank all results with BM25 and re-extract snippets with global frequencies
			if len(m.fileJobs) > 0 {
				testIntent := ranker.HasTestIntent(strings.Fields(m.searchInput.Value()))
				ranked := ranker.RankResults(m.cfg.Ranker, m.textFileCount, m.fileJobs, m.cfg.StructuralRankerConfig(), m.cfg.ResolveRankingProfile(), testIntent)

				if m.cfg.Dedup {
					ranked = ranker.DeduplicateResults(ranked)
				}

				docFreq := ranker.CalculateDocumentTermFrequency(ranked)

				// Parse snippet length from input
				snippetLen := 300
				if v := m.snippetInput.Value(); v != "" {
					fmt.Sscanf(v, "%d", &snippetLen)
				}

				ctxBefore, ctxAfter := m.cfg.ResolveContext()
				var newResults []searchResult
				for _, fj := range ranked {
					fileMode := resolveSnippetMode(m.snippetMode, fj.Filename)
					isProse := snippet.IsProseFile(fj.Extension)
					if fileMode == "grep" {
						lineResults := snippet.FindAllMatchingLines(fj, m.cfg.LineLimit, ctxBefore, ctxAfter)
						var clusters [][]snippet.LineResult
						if len(lineResults) > 0 {
							clusters = [][]snippet.LineResult{lineResults}
						}
						fj.Content = nil
						newResults = append(newResults, searchResult{
							Filename:       fj.Location,
							Location:       fj.Location,
							Score:          fj.Score,
							LineClusters:   clusters,
							Language:       fj.Language,
							TotalLines:     fj.Lines,
							Code:           fj.Code,
							Comment:        fj.Comment,
							Blank:          fj.Blank,
							Complexity:     fj.Complexity,
							DuplicateCount: fj.DuplicateCount,
							MatchLocations: fj.MatchLocations,
							Prose:          isProse,
						})
					} else if fileMode == "lines" {
						surroundLines := snippetLen / 100
						if surroundLines < 1 {
							surroundLines = 1
						}
						clusters := snippet.FindMatchingLinesMulti(fj, surroundLines, m.cfg.SnippetCount)
						fj.Content = nil
						newResults = append(newResults, searchResult{
							Filename:       fj.Location,
							Location:       fj.Location,
							Score:          fj.Score,
							LineClusters:   clusters,
							Language:       fj.Language,
							TotalLines:     fj.Lines,
							Code:           fj.Code,
							Comment:        fj.Comment,
							Blank:          fj.Blank,
							Complexity:     fj.Complexity,
							DuplicateCount: fj.DuplicateCount,
							MatchLocations: fj.MatchLocations,
							Prose:          isProse,
						})
					} else {
						snippets := snippet.ExtractRelevant(fj, docFreq, snippetLen)
						if m.cfg.SnippetCount > 0 && len(snippets) > m.cfg.SnippetCount {
							snippets = snippets[:m.cfg.SnippetCount]
						}
						fj.Content = nil
						newResults = append(newResults, searchResult{
							Filename:       fj.Location,
							Location:       fj.Location,
							Score:          fj.Score,
							Snippets:       snippets,
							SnippetIdx:     0,
							Language:       fj.Language,
							TotalLines:     fj.Lines,
							Code:           fj.Code,
							Comment:        fj.Comment,
							Blank:          fj.Blank,
							Complexity:     fj.Complexity,
							DuplicateCount: fj.DuplicateCount,
							MatchLocations: fj.MatchLocations,
							Prose:          isProse,
						})
					}
				}
				m.results = newResults
				m.fileJobs = nil
				m.selectedIndex = 0
				m.scrollOffset = 0
			}

			return m, nil
		}
		// Keep listening for more results
		return m, listenForResults(m.searchResults)

	case tea.MouseMsg:
		m.errMsg = ""
		if m.viewing {
			maxViewScroll := max(0, len(m.viewLines)-(m.windowHeight-3))
			switch msg.Type {
			case tea.MouseWheelUp:
				m.viewScroll = max(0, m.viewScroll-3)
			case tea.MouseWheelDown:
				m.viewScroll = min(maxViewScroll, m.viewScroll+3)
			}
			return m, nil
		}
		switch msg.Type {
		case tea.MouseWheelUp:
			m.scrollOffset -= 3
			m.clampScroll()
			m.syncSelectedToScroll()
			return m, nil
		case tea.MouseWheelDown:
			m.scrollOffset += 3
			m.clampScroll()
			m.syncSelectedToScroll()
			return m, nil
		case tea.MouseLeft:
			idx := m.resultIndexAtY(msg.Y)
			if idx >= 0 && idx < len(m.results) {
				m.selectedIndex = idx
			}
			return m, nil
		}

	case editorErrMsg:
		if msg.err != nil {
			m.errMsg = fmt.Sprintf("editor failed: %v", msg.err)
		}
		return m, nil

	case tea.KeyMsg:
		m.errMsg = ""
		if m.viewing {
			maxViewScroll := max(0, len(m.viewLines)-(m.windowHeight-3))
			switch msg.Type {
			case tea.KeyEsc, tea.KeyF5, tea.KeyCtrlO, tea.KeyCtrlP:
				m.viewing = false
				m.viewLines = nil // free memory
				return m, nil
			case tea.KeyUp:
				m.viewScroll = max(0, m.viewScroll-1)
				return m, nil
			case tea.KeyDown:
				m.viewScroll = min(maxViewScroll, m.viewScroll+1)
				return m, nil
			case tea.KeyPgUp:
				m.viewScroll = max(0, m.viewScroll-(m.windowHeight-4))
				return m, nil
			case tea.KeyPgDown:
				m.viewScroll = min(maxViewScroll, m.viewScroll+(m.windowHeight-4))
				return m, nil
			case tea.KeyEnter:
				if m.cfg.Format == "vimgrep" {
					m.chosen = tuiVimGrep(m.cfg, m.viewLocation, m.viewMatchLocs)
				} else {
					m.chosen = m.viewLocation
				}
				return m, tea.Quit
			case tea.KeyCtrlE:
				return m, editorAtLine(m.viewLocation, m.viewStartLine+1)
			case tea.KeyRunes:
				if string(msg.Runes) == "o" {
					return m, editorAtLine(m.viewLocation, m.viewStartLine+1)
				}
			}
			return m, nil
		}
		switch msg.Type {
		case tea.KeyCtrlC, tea.KeyEsc:
			if m.searchCancel != nil {
				m.searchCancel()
			}
			return m, tea.Quit

		case tea.KeyEnter:
			if len(m.results) > 0 && m.selectedIndex < len(m.results) {
				if m.searchCancel != nil {
					m.searchCancel()
				}
				r := m.results[m.selectedIndex]
				if m.cfg.Format == "vimgrep" {
					m.chosen = tuiVimGrep(m.cfg, r.Location, r.MatchLocations)
				} else {
					m.chosen = r.Location
				}
				return m, tea.Quit
			}
			return m, nil

		case tea.KeyTab, tea.KeyShiftTab:
			switch m.focusIndex {
			case 0:
				m.focusIndex = 1
				m.searchInput.Blur()
				m.snippetInput.Focus()
			case 2:
				m.focusIndex = 0
				m.searchInput.Focus()
			default:
				m.focusIndex = 0
				m.snippetInput.Blur()
				m.searchInput.Focus()
			}
			return m, nil

		case tea.KeyUp:
			if m.focusIndex == 1 {
				m.adjustSnippetLength(100)
				if q := strings.TrimSpace(m.searchInput.Value()); q != "" {
					m.searchSeq++
					return m, makeDebounceCmd(m.searchSeq, m.searchInput.Value())
				}
				return m, nil
			}
			if m.focusIndex == 2 {
				if m.selectedIndex > 0 {
					m.selectedIndex--
					m.ensureVisible()
				} else {
					m.focusIndex = 0
					m.searchInput.Focus()
				}
				return m, nil
			}
			if m.selectedIndex > 0 {
				m.selectedIndex--
				m.ensureVisible()
			}
			return m, nil

		case tea.KeyDown:
			if m.focusIndex == 1 {
				m.adjustSnippetLength(-100)
				if q := strings.TrimSpace(m.searchInput.Value()); q != "" {
					m.searchSeq++
					return m, makeDebounceCmd(m.searchSeq, m.searchInput.Value())
				}
				return m, nil
			}
			if m.focusIndex == 0 && m.cfg.SnippetCount > 1 && len(m.results) > 0 {
				m.focusIndex = 2
				m.searchInput.Blur()
				return m, nil
			}
			if m.selectedIndex < len(m.results)-1 {
				m.selectedIndex++
				m.ensureVisible()
			}
			return m, nil

		case tea.KeyLeft:
			if m.focusIndex == 2 && m.selectedIndex < len(m.results) {
				r := &m.results[m.selectedIndex]
				if r.SnippetIdx > 0 {
					r.SnippetIdx--
				}
				return m, nil
			}

		case tea.KeyRight:
			if m.focusIndex == 2 && m.selectedIndex < len(m.results) {
				r := &m.results[m.selectedIndex]
				if r.SnippetIdx < r.snippetCount()-1 {
					r.SnippetIdx++
				}
				return m, nil
			}

		case tea.KeyPgUp:
			if m.focusIndex == 1 {
				m.adjustSnippetLength(200)
				if q := strings.TrimSpace(m.searchInput.Value()); q != "" {
					m.searchSeq++
					return m, makeDebounceCmd(m.searchSeq, m.searchInput.Value())
				}
				return m, nil
			}

		case tea.KeyPgDown:
			if m.focusIndex == 1 {
				m.adjustSnippetLength(-200)
				if q := strings.TrimSpace(m.searchInput.Value()); q != "" {
					m.searchSeq++
					return m, makeDebounceCmd(m.searchSeq, m.searchInput.Value())
				}
				return m, nil
			}

		case tea.KeyF1:
			m.cycleRanker()
			return m, m.retriggerSearch()
		case tea.KeyF2:
			m.cycleCodeFilter()
			return m, m.retriggerSearch()
		case tea.KeyF3:
			m.cycleGravity()
			return m, m.retriggerSearch()
		case tea.KeyF4:
			m.cycleNoise()
			return m, m.retriggerSearch()
		case tea.KeyF5, tea.KeyCtrlO, tea.KeyCtrlP:
			if len(m.results) > 0 && m.selectedIndex < len(m.results) {
				if err := m.openViewer(m.results[m.selectedIndex]); err != nil {
					m.errMsg = fmt.Sprintf("cannot open file: %v", err)
				}
			}
			return m, nil
		case tea.KeyF6:
			m.cycleSnippetMode()
			return m, m.retriggerSearch()
		case tea.KeyCtrlE:
			if len(m.results) > 0 && m.selectedIndex < len(m.results) {
				r := m.results[m.selectedIndex]
				lineNum := 0
				if lr := r.activeLineRange(); lr != "" {
					fmt.Sscanf(lr, "%d", &lineNum)
				}
				return m, editorAtLine(r.Location, lineNum)
			}
			return m, nil
		}

		// In result-nav focus, a printable key returns focus to the search
		// input and feeds the key through so typing resumes immediately.
		if m.focusIndex == 2 && msg.Type == tea.KeyRunes {
			m.focusIndex = 0
			m.searchInput.Focus()
		}
	}

	// Update the focused input
	switch m.focusIndex {
	case 0:
		prevValue := m.searchInput.Value()
		var cmd tea.Cmd
		m.searchInput, cmd = m.searchInput.Update(msg)
		cmds = append(cmds, cmd)

		// On text change, increment seq and start debounce timer
		if m.searchInput.Value() != prevValue {
			m.searchSeq++
			cmds = append(cmds, makeDebounceCmd(m.searchSeq, m.searchInput.Value()))
		}
	case 1:
		var cmd tea.Cmd
		m.snippetInput, cmd = m.snippetInput.Update(msg)
		cmds = append(cmds, cmd)
	}

	return m, tea.Batch(cmds...)
}

func (m *model) adjustSnippetLength(delta int) {
	val := 300
	if v := m.snippetInput.Value(); v != "" {
		fmt.Sscanf(v, "%d", &val)
	}
	val += delta
	if val < 100 {
		val = 100
	}
	if val > 8000 {
		val = 8000
	}
	m.snippetInput.SetValue(fmt.Sprintf("%d", val))
}

// makeDebounceCmd returns a tea.Cmd that fires a debounceTickMsg after 200ms
func makeDebounceCmd(seq int, query string) tea.Cmd {
	return tea.Tick(200*time.Millisecond, func(t time.Time) tea.Msg {
		return debounceTickMsg{seq: seq, query: query}
	})
}

// listenForResults returns a tea.Cmd that blocks until the next message arrives on ch
func listenForResults(ch <-chan searchResultsMsg) tea.Cmd {
	return func() tea.Msg {
		msg, ok := <-ch
		if !ok {
			return searchResultsMsg{done: true}
		}
		return msg
	}
}

// realSearch wraps DoSearch for TUI use, streaming results in batches via the channel.
func realSearch(ctx context.Context, cfg *Config, seq int, query string, snippetLen int, snippetMode string, cache *SearchCache, ch chan<- searchResultsMsg) {
	defer close(ch)

	searchCh, stats, err := DoSearch(ctx, cfg, query, cache)
	if err != nil {
		select {
		case ch <- searchResultsMsg{seq: seq, done: true}:
		case <-ctx.Done():
		}
		return
	}

	var batch []searchResult
	var batchJobs []*common.FileJob

	ctxBefore, ctxAfter := cfg.ResolveContext()
	for fj := range searchCh {
		// Build a preliminary searchResult for immediate display
		fileMode := resolveSnippetMode(snippetMode, fj.Filename)
		isProse := snippet.IsProseFile(fj.Extension)
		var sr searchResult
		if fileMode == "grep" {
			lineResults := snippet.FindAllMatchingLines(fj, cfg.LineLimit, ctxBefore, ctxAfter)
			var clusters [][]snippet.LineResult
			if len(lineResults) > 0 {
				clusters = [][]snippet.LineResult{lineResults}
			}
			sr = searchResult{
				Filename:       fj.Location,
				Location:       fj.Location,
				LineClusters:   clusters,
				Language:       fj.Language,
				TotalLines:     fj.Lines,
				Code:           fj.Code,
				Comment:        fj.Comment,
				Blank:          fj.Blank,
				Complexity:     fj.Complexity,
				MatchLocations: fj.MatchLocations,
				Prose:          isProse,
			}
		} else if fileMode == "lines" {
			clusters := snippet.FindMatchingLinesMulti(fj, 2, cfg.SnippetCount)
			sr = searchResult{
				Filename:       fj.Location,
				Location:       fj.Location,
				LineClusters:   clusters,
				Language:       fj.Language,
				TotalLines:     fj.Lines,
				Code:           fj.Code,
				Comment:        fj.Comment,
				Blank:          fj.Blank,
				Complexity:     fj.Complexity,
				MatchLocations: fj.MatchLocations,
				Prose:          isProse,
			}
		} else {
			docFreq := make(map[string]int, len(fj.MatchLocations))
			for k, v := range fj.MatchLocations {
				docFreq[k] = len(v)
			}
			snippets := snippet.ExtractRelevant(fj, docFreq, snippetLen)
			if cfg.SnippetCount > 0 && len(snippets) > cfg.SnippetCount {
				snippets = snippets[:cfg.SnippetCount]
			}
			sr = searchResult{
				Filename:       fj.Location,
				Location:       fj.Location,
				Snippets:       snippets,
				SnippetIdx:     0,
				Language:       fj.Language,
				TotalLines:     fj.Lines,
				Code:           fj.Code,
				Comment:        fj.Comment,
				Blank:          fj.Blank,
				Complexity:     fj.Complexity,
				MatchLocations: fj.MatchLocations,
				Prose:          isProse,
			}
		}

		batch = append(batch, sr)
		batchJobs = append(batchJobs, fj)

		if len(batch) >= 5 {
			select {
			case ch <- searchResultsMsg{
				seq: seq, results: batch, fileJobs: batchJobs,
				total: int(stats.FileCount.Load()), textTotal: int(stats.TextFileCount.Load()),
			}:
				batch = nil
				batchJobs = nil
			case <-ctx.Done():
				return
			}
		}
	}

	// Send remaining results + done signal
	select {
	case ch <- searchResultsMsg{
		seq: seq, results: batch, fileJobs: batchJobs,
		done: true, total: int(stats.FileCount.Load()), textTotal: int(stats.TextFileCount.Load()),
	}:
	case <-ctx.Done():
	}
}

// snippetMatchLocs filters match locations to those within [startPos, endPos]
// and adjusts them to be relative to startPos (matching console.go behavior).
func snippetMatchLocs(matchLocations map[string][][]int, startPos, endPos int) [][]int {
	var locs [][]int
	for _, value := range matchLocations {
		for _, s := range value {
			if len(s) < 2 {
				continue
			}
			if s[0] >= startPos && s[1] <= endPos {
				locs = append(locs, []int{
					s[0] - startPos,
					s[1] - startPos,
				})
			}
		}
	}
	return locs
}

// resultHeight returns the number of terminal lines a result takes up
func (m *model) resultHeight(r searchResult) int {
	height := 1 // title
	if cluster := r.activeCluster(); cluster != nil {
		gaps := 0
		for i := 1; i < len(cluster); i++ {
			if cluster[i].LineNumber > cluster[i-1].LineNumber+1 {
				gaps++
			}
		}
		height += len(cluster) + gaps + 1 // lines + gap blanks + trailing blank
	} else {
		snippetText := ""
		if s := r.activeSnippet(); s != nil {
			snippetText = s.Content
		}
		lines := strings.Count(snippetText, "\n") + 1
		height += lines + 1 // lines + trailing blank
	}
	// Reserve a line for the "< N of M snippets >" counter when cycling is
	// enabled and we have at least one snippet/cluster (matches renderResult).
	if m.cfg.SnippetCount > 1 && r.snippetCount() >= 1 {
		height++
	}
	return height
}

func (m *model) totalContentHeight() int {
	total := 0
	for _, r := range m.results {
		total += m.resultHeight(r)
	}
	return total
}

func (m *model) clampScroll() {
	if m.scrollOffset < 0 {
		m.scrollOffset = 0
	}
	availHeight := m.windowHeight - 5
	if availHeight < 1 {
		availHeight = 1
	}
	maxScroll := m.totalContentHeight() - availHeight
	if maxScroll < 0 {
		maxScroll = 0
	}
	if m.scrollOffset > maxScroll {
		m.scrollOffset = maxScroll
	}
}

func (m *model) resultIndexAtY(y int) int {
	const headerLines = 2
	if y < headerLines {
		return -1
	}
	contentLine := m.scrollOffset + (y - headerLines)
	accum := 0
	for i, r := range m.results {
		rh := m.resultHeight(r)
		if contentLine < accum+rh {
			return i
		}
		accum += rh
	}
	return -1
}

func (m *model) syncSelectedToScroll() {
	if len(m.results) == 0 {
		return
	}
	availHeight := m.windowHeight - 5
	if availHeight < 1 {
		availHeight = 1
	}
	accum := 0
	firstVisible, lastVisible := -1, -1
	for i, r := range m.results {
		rh := m.resultHeight(r)
		if accum+rh > m.scrollOffset && accum < m.scrollOffset+availHeight {
			if firstVisible == -1 {
				firstVisible = i
			}
			lastVisible = i
		}
		accum += rh
		if accum >= m.scrollOffset+availHeight && lastVisible >= 0 {
			break
		}
	}
	if firstVisible == -1 {
		return
	}
	if m.selectedIndex < firstVisible {
		m.selectedIndex = firstVisible
	}
	if m.selectedIndex > lastVisible {
		m.selectedIndex = lastVisible
	}
}

func (m *model) ensureVisible() {
	// Calculate available height for results area
	availHeight := m.windowHeight - 5 // input + status + separator + bottom bar + overhead

	// Make sure selected item is visible by adjusting scroll offset
	heightBefore := 0
	for i := 0; i < m.selectedIndex; i++ {
		if i < len(m.results) {
			heightBefore += m.resultHeight(m.results[i])
		}
	}

	selectedH := 0
	if m.selectedIndex < len(m.results) {
		selectedH = m.resultHeight(m.results[m.selectedIndex])
	}

	// Scroll up if selected is above viewport
	if heightBefore < m.scrollOffset {
		m.scrollOffset = heightBefore
	}

	// Scroll down if selected is below viewport
	if heightBefore+selectedH > m.scrollOffset+availHeight {
		m.scrollOffset = heightBefore + selectedH - availHeight
	}

	m.clampScroll()
}

// cycleRanker cycles the ranker through: simple → tfidf → bm25 → structural → simple…
func (m *model) cycleRanker() {
	order := []string{"simple", "tfidf", "bm25", "structural", "min"}
	for i, v := range order {
		if v == m.cfg.Ranker {
			m.cfg.Ranker = order[(i+1)%len(order)]
			return
		}
	}
	m.cfg.Ranker = "simple"
}

// cycleCodeFilter cycles: default → only-code → only-comments → only-strings → only-declarations → only-usages → default…
// Auto-switches ranker to "structural" when a filter is active.
func (m *model) cycleCodeFilter() {
	switch {
	case !m.cfg.OnlyCode && !m.cfg.OnlyComments && !m.cfg.OnlyStrings && !m.cfg.OnlyDeclarations && !m.cfg.OnlyUsages:
		m.cfg.OnlyCode = true
	case m.cfg.OnlyCode:
		m.cfg.OnlyCode = false
		m.cfg.OnlyComments = true
	case m.cfg.OnlyComments:
		m.cfg.OnlyComments = false
		m.cfg.OnlyStrings = true
	case m.cfg.OnlyStrings:
		m.cfg.OnlyStrings = false
		m.cfg.OnlyDeclarations = true
	case m.cfg.OnlyDeclarations:
		m.cfg.OnlyDeclarations = false
		m.cfg.OnlyUsages = true
	case m.cfg.OnlyUsages:
		m.cfg.OnlyUsages = false
	}
	if m.cfg.HasContentFilter() {
		m.cfg.Ranker = "structural"
	}
}

// cycleGravity cycles: off → low → default → logic → brain → off…
func (m *model) cycleGravity() {
	order := []string{"off", "low", "default", "logic", "brain"}
	for i, v := range order {
		if v == m.cfg.GravityIntent {
			m.cfg.GravityIntent = order[(i+1)%len(order)]
			return
		}
	}
	m.cfg.GravityIntent = "off"
}

// cycleNoise cycles: silence → quiet → default → loud → raw → silence…
func (m *model) cycleNoise() {
	order := []string{"silence", "quiet", "default", "loud", "raw"}
	for i, v := range order {
		if v == m.cfg.NoiseIntent {
			m.cfg.NoiseIntent = order[(i+1)%len(order)]
			return
		}
	}
	m.cfg.NoiseIntent = "silence"
}

// cycleSnippetMode cycles: auto → snippet → lines → grep → auto…
func (m *model) cycleSnippetMode() {
	order := []string{"auto", "snippet", "lines", "grep"}
	for i, v := range order {
		if v == m.snippetMode {
			m.snippetMode = order[(i+1)%len(order)]
			return
		}
	}
	m.snippetMode = "auto"
}

// retriggerSearch bumps the search sequence and returns a debounce command to re-execute the current query.
func (m *model) retriggerSearch() tea.Cmd {
	m.searchSeq++
	return makeDebounceCmd(m.searchSeq, m.searchInput.Value())
}

// tuiVimGrep re-reads a file and formats all matches as vimgrep lines.
// Mirrors the branch structure of formatVimGrep in console.go.
func tuiVimGrep(cfg *Config, location string, matchLocations map[string][][]int) string {
	content, err := readFileContent(location, cfg.MaxReadSizeBytes)
	if err != nil {
		return location
	}
	fj := &common.FileJob{
		Filename:       location,
		Location:       location,
		Content:        content,
		MatchLocations: matchLocations,
	}
	fileMode := resolveSnippetMode(cfg.SnippetMode, location)

	var vimGrepOutput []string
	if fileMode == "grep" {
		lineResults := snippet.FindAllMatchingLines(fj, cfg.LineLimit, 0, 0)
		for _, lr := range lineResults {
			col := 1
			if len(lr.Locs) > 0 {
				col = lr.Locs[0][0] + 1
			}
			hint := strings.ReplaceAll(lr.Content, "\n", "\\n")
			line := fmt.Sprintf("%v:%v:%v:%v", location, lr.LineNumber, col, hint)
			vimGrepOutput = append(vimGrepOutput, line)
		}
	} else if fileMode == "lines" {
		lineResults := snippet.FindMatchingLines(fj, 0)
		for _, lr := range lineResults {
			col := 1
			if len(lr.Locs) > 0 {
				col = lr.Locs[0][0] + 1
			}
			hint := strings.ReplaceAll(lr.Content, "\n", "\\n")
			line := fmt.Sprintf("%v:%v:%v:%v", location, lr.LineNumber, col, hint)
			vimGrepOutput = append(vimGrepOutput, line)
		}
	} else {
		docFreq := make(map[string]int, len(matchLocations))
		for k, v := range matchLocations {
			docFreq[k] = len(v)
		}
		snippets := snippet.ExtractRelevant(fj, docFreq, 50)
		if len(snippets) > cfg.SnippetCount {
			snippets = snippets[:cfg.SnippetCount]
		}
		for _, snip := range snippets {
			hint := strings.ReplaceAll(snip.Content, "\n", "\\n")
			line := fmt.Sprintf("%v:%v:%v:%v", location, snip.LineStart, snip.StartPos, hint)
			vimGrepOutput = append(vimGrepOutput, line)
		}
	}

	if len(vimGrepOutput) == 0 {
		return location
	}
	return strings.Join(vimGrepOutput, "\n")
}

// codeFilterLabel returns a display label for the current code filter state.
func (m *model) codeFilterLabel() string {
	switch {
	case m.cfg.OnlyCode:
		return "only-code"
	case m.cfg.OnlyComments:
		return "only-comments"
	case m.cfg.OnlyStrings:
		return "only-strings"
	case m.cfg.OnlyDeclarations:
		return "only-declarations"
	case m.cfg.OnlyUsages:
		return "only-usages"
	default:
		return "default"
	}
}

func (m model) View() string {
	if m.windowWidth == 0 {
		return "loading..."
	}

	if m.viewing {
		return m.renderViewer()
	}

	var b strings.Builder

	// === Top line: search input + snippet length ===
	snippetLabel := snippetLabelStyle.Render("[" + m.snippetInput.View() + "]")
	snippetWidth := lipgloss.Width(snippetLabel)
	searchWidth := m.windowWidth - snippetWidth - 1
	if searchWidth < 10 {
		searchWidth = 10
	}
	m.searchInput.Width = searchWidth - 3 // account for prompt "> "

	topLine := lipgloss.JoinHorizontal(lipgloss.Top,
		lipgloss.NewStyle().Width(searchWidth).Render(m.searchInput.View()),
		lipgloss.NewStyle().Width(snippetWidth).Align(lipgloss.Right).Render(snippetLabel),
	)
	b.WriteString(topLine)
	b.WriteString("\n")

	// === Status line ===
	query := m.searchInput.Value()
	var status string
	if m.errMsg != "" {
		status = m.errMsg
	} else if query == "" {
		status = "type a query to search"
	} else if m.searching {
		status = fmt.Sprintf("%d results for '%s' from %d files (searching...)",
			len(m.results), query, m.fileCount)
	} else {
		plural := "s"
		if len(m.results) == 1 {
			plural = ""
		}
		status = fmt.Sprintf("%d result%s for '%s' from %d files",
			len(m.results), plural, m.lastQuery, m.fileCount)
	}
	b.WriteString(statusStyle.Render(status))
	b.WriteString("\n")

	// === Results area ===
	availHeight := m.windowHeight - 5 // input + status + separator + bottom bar + overhead
	if availHeight < 1 {
		availHeight = 1
	}

	linesRendered := 0
	linesSkipped := 0

	for i, r := range m.results {
		rh := m.resultHeight(r)

		// Skip results that are above the scroll offset
		if linesSkipped+rh <= m.scrollOffset {
			linesSkipped += rh
			continue
		}

		// Stop if we've filled the viewport
		if linesRendered >= availHeight {
			break
		}

		isSelected := i == m.selectedIndex
		resultStr := m.renderResult(r, isSelected)
		resultLines := strings.Split(resultStr, "\n")

		// Handle partial rendering at top (scroll offset cuts into this result)
		startLine := 0
		if linesSkipped < m.scrollOffset {
			startLine = m.scrollOffset - linesSkipped
			linesSkipped = m.scrollOffset
		}

		for j := startLine; j < len(resultLines); j++ {
			if linesRendered >= availHeight {
				break
			}
			b.WriteString(resultLines[j])
			b.WriteString("\n")
			linesRendered++
		}
	}

	// Fill remaining space so alt screen doesn't look jagged
	for linesRendered < availHeight {
		b.WriteString("\n")
		linesRendered++
	}

	// === Bottom bar (nano-style keybinding hints) ===
	hint := fmt.Sprintf(
		"F1 Ranker:%s  F2 Filter:%s  F3 Gravity:%s  F4 Noise:%s  F5/^O/^P View  F6 Snippet:%s",
		m.cfg.Ranker, m.codeFilterLabel(), m.cfg.GravityIntent, m.cfg.NoiseIntent, m.snippetMode)
	if m.cfg.SnippetCount > 1 {
		hint += "  ↓ then ←/→ Cycle"
	}
	bottomBar := snippetLabelStyle.Render(hint)
	b.WriteString("\n")
	b.WriteString(bottomBar)

	return b.String()
}

func (m model) renderResult(r searchResult, isSelected bool) string {
	var b strings.Builder

	// Title line: indicator + filename (language) (score) [linerange] code stats
	codeStats := ""
	if r.TotalLines > 0 {
		codeStats = fmt.Sprintf(" Lines:%d (Code:%d Comment:%d Blank:%d Complexity:%d)", r.TotalLines, r.Code, r.Comment, r.Blank, r.Complexity)
	}
	lineRange := r.activeLineRange()
	var titleText string
	if r.Language != "" {
		titleText = fmt.Sprintf("%s (%s) (%0.4f) [%s]%s", r.Filename, r.Language, r.Score, lineRange, codeStats)
	} else {
		titleText = fmt.Sprintf("%s (%0.4f) [%s]%s", r.Filename, r.Score, lineRange, codeStats)
	}
	if r.DuplicateCount > 0 {
		titleText += fmt.Sprintf(" [+%d duplicates]", r.DuplicateCount)
	}

	// In result-nav focus, brighten the selected indicator so the user can
	// see that Left/Right will cycle snippets on this row.
	indicator := selectedIndicator.String()
	if isSelected && m.focusIndex == 2 {
		indicator = navIndicator.String()
	}

	if isSelected {
		b.WriteString(indicator)
		b.WriteString(selectedTitleStyle.Render(titleText))
	} else {
		b.WriteString(" ")
		b.WriteString(titleStyle.Render(titleText))
	}
	b.WriteString("\n")

	// Render content: line-based (active cluster) or free-text snippet.
	if cluster := r.activeCluster(); cluster != nil {
		prevLine := 0
		for _, lr := range cluster {
			if prevLine > 0 && lr.LineNumber > prevLine+1 {
				b.WriteString("\n")
			}
			prevLine = lr.LineNumber
			prefix := "  "
			if isSelected {
				prefix = indicator + " "
			}
			lineNum := snippetLabelStyle.Render(fmt.Sprintf("%4d ", lr.LineNumber))
			highlighted := m.highlightWithLocs(lr.Content, lr.Locs, isSelected, r.Prose)
			b.WriteString(prefix + lineNum + highlighted)
			b.WriteString("\n")
		}
	} else {
		active := r.activeSnippet()
		snippetText := ""
		var sLocs [][]int
		if active != nil {
			snippetText = active.Content
			sLocs = snippetMatchLocs(r.MatchLocations, active.StartPos, active.EndPos)
		}
		snippetLines := strings.Split(snippetText, "\n")
		offset := 0
		for _, line := range snippetLines {
			prefix := "  "
			if isSelected {
				prefix = indicator + " "
			}

			// Compute per-line match locations from snippet-wide locs
			var lineLocs [][]int
			lineEnd := offset + len(line)
			for _, loc := range sLocs {
				if loc[1] <= offset || loc[0] >= lineEnd {
					continue // outside this line
				}
				start := loc[0] - offset
				end := loc[1] - offset
				if start < 0 {
					start = 0
				}
				if end > len(line) {
					end = len(line)
				}
				lineLocs = append(lineLocs, []int{start, end})
			}

			highlighted := m.highlightWithLocs(line, lineLocs, isSelected, r.Prose)
			b.WriteString(prefix + highlighted)
			b.WriteString("\n")
			offset = lineEnd + 1 // +1 for the \n
		}
	}

	// Counter line: shown for the selected result whenever cycling is enabled
	// (SnippetCount > 1) and there's at least one snippet/cluster. Applies in
	// both snippet and lines modes. Non-selected rows render a blank line so
	// scroll math (resultHeight) stays stable.
	total := r.snippetCount()
	if m.cfg.SnippetCount > 1 && total >= 1 {
		if isSelected {
			style := snippetCounterStyle
			if m.focusIndex == 2 {
				style = snippetCounterActiveStyle
			}
			noun := "snippets"
			if total == 1 {
				noun = "snippet"
			}
			counter := fmt.Sprintf("  < %d of %d %s >", r.activeIdx()+1, total, noun)
			b.WriteString(style.Render(counter))
			b.WriteString("\n")
		} else {
			b.WriteString("\n")
		}
	}

	return b.String()
}

func (m model) highlightWithLocs(line string, locs [][]int, isSelected bool, prose bool) string {
	if !m.cfg.NoSyntax {
		return RenderLipglossLine(line, locs, isSelected, prose)
	}
	return highlightMatchOnly(line, locs, isSelected)
}

// highlightMatchOnly is the original match-only highlighting (no syntax colors).
func highlightMatchOnly(line string, locs [][]int, isSelected bool) string {
	normal := snippetStyle
	highlight := matchStyle
	if isSelected {
		normal = selectedSnippetStyle
		highlight = selectedMatchStyle
	}

	if len(locs) == 0 {
		return normal.Render(line)
	}

	marked := make([]bool, len(line))
	for _, loc := range locs {
		if len(loc) < 2 || loc[0] < 0 {
			continue
		}
		for i := loc[0]; i < loc[1] && i < len(marked); i++ {
			marked[i] = true
		}
	}

	var result strings.Builder
	inMatch := false
	segStart := 0

	for i := 0; i <= len(line); i++ {
		currentMatch := i < len(line) && marked[i]
		if i == len(line) || currentMatch != inMatch {
			seg := line[segStart:i]
			if inMatch {
				result.WriteString(highlight.Render(seg))
			} else {
				result.WriteString(normal.Render(seg))
			}
			segStart = i
			inMatch = currentMatch
		}
	}

	return result.String()
}

// editorErrMsg is delivered after tea.ExecProcess returns from the editor
// so the TUI can surface a failure without crashing.
type editorErrMsg struct{ err error }

// editorAtLine suspends the TUI, runs the user's editor on location (jumping
// to lineNum for editors that accept +N), and resumes the TUI on exit.
// Editor is taken from CS_EDITOR, then EDITOR, defaulting to vim.
func editorAtLine(location string, lineNum int) tea.Cmd {
	if location == "" {
		return nil
	}
	editor := os.Getenv("CS_EDITOR")
	if editor == "" {
		editor = os.Getenv("EDITOR")
	}
	if editor == "" {
		editor = "vim"
	}
	parts := strings.Fields(editor)
	if len(parts) == 0 {
		return nil
	}
	args := parts[1:]
	filePart := location
	if lineNum > 0 {
		switch filepath.Base(parts[0]) {
		case "vi", "vim", "nvim", "hx", "nano", "emacs":
			args = append([]string{fmt.Sprintf("+%d", lineNum)}, args...)
		case "code", "code-insiders", "codium", "cursor":
			// VS Code family: `code -g <file>:<line>` jumps to the line.
			// Note: without --wait in $CS_EDITOR / $EDITOR, code returns
			// immediately and the TUI redraws right away.
			args = append(args, "-g")
			filePart = fmt.Sprintf("%s:%d", location, lineNum)
		}
	}
	args = append(args, filePart)
	cmd := exec.Command(parts[0], args...)
	return tea.ExecProcess(cmd, func(err error) tea.Msg {
		if err != nil {
			return editorErrMsg{err: err}
		}
		return nil
	})
}

// openViewer reads the file from disk and sets up the viewer overlay state.
func (m *model) openViewer(r searchResult) error {
	data, err := os.ReadFile(r.Location)
	if err != nil {
		return err
	}

	lines := strings.Split(string(data), "\n")

	// Build line byte offsets for match position mapping
	offsets := make([]int, len(lines))
	pos := 0
	for i, line := range lines {
		offsets[i] = pos
		pos += len(line) + 1 // +1 for \n
	}

	// Parse start line from active snippet (snippet mode) or LineRange (grep/lines).
	lineRange := r.activeLineRange()
	startLine := 0
	if lineRange != "" {
		fmt.Sscanf(lineRange, "%d", &startLine)
		startLine-- // convert to 0-based
	}

	m.viewing = true
	m.viewLines = lines
	maxViewScroll := max(0, len(lines)-(m.windowHeight-3))
	m.viewScroll = min(maxViewScroll, max(0, startLine-(m.windowHeight-4)/2)) // center match
	m.viewFilename = r.Filename
	m.viewLocation = r.Location
	m.viewLanguage = r.Language
	m.viewLineRange = lineRange
	m.viewMatchLocs = r.MatchLocations
	m.viewLineOffsets = offsets
	m.viewProse = r.Prose
	m.viewStartLine = startLine
	return nil
}

// viewerMatchLocsForLine converts absolute byte-offset match locations to
// per-line relative positions for a given line index.
func (m model) viewerMatchLocsForLine(lineIdx int) [][]int {
	if lineIdx < 0 || lineIdx >= len(m.viewLines) || m.viewMatchLocs == nil {
		return nil
	}
	lineStart := m.viewLineOffsets[lineIdx]
	lineEnd := lineStart + len(m.viewLines[lineIdx])

	var locs [][]int
	for _, positions := range m.viewMatchLocs {
		for _, loc := range positions {
			if len(loc) < 2 {
				continue
			}
			if loc[1] <= lineStart || loc[0] >= lineEnd {
				continue
			}
			start := loc[0] - lineStart
			end := loc[1] - lineStart
			if start < 0 {
				start = 0
			}
			if end > len(m.viewLines[lineIdx]) {
				end = len(m.viewLines[lineIdx])
			}
			locs = append(locs, []int{start, end})
		}
	}
	return locs
}

// renderViewer renders the full-screen file viewer overlay.
func (m model) renderViewer() string {
	var b strings.Builder

	// === Title bar ===
	langStr := ""
	if m.viewLanguage != "" {
		langStr = " (" + m.viewLanguage + ")"
	}
	rangeStr := ""
	if m.viewLineRange != "" {
		rangeStr = " [" + m.viewLineRange + "]"
	}
	titleLeft := fmt.Sprintf("  %s%s%s", m.viewFilename, langStr, rangeStr)
	titleRight := fmt.Sprintf("line %d/%d  ", m.viewScroll+1, len(m.viewLines))

	padding := m.windowWidth - lipgloss.Width(titleLeft) - lipgloss.Width(titleRight)
	if padding < 1 {
		padding = 1
	}
	titleBar := selectedTitleStyle.Render(titleLeft) + strings.Repeat(" ", padding) + statusStyle.Render(titleRight)
	b.WriteString(titleBar)
	b.WriteString("\n")

	// === Content area ===
	contentHeight := m.windowHeight - 3 // title + bottom bar + bottom bar newline
	if contentHeight < 1 {
		contentHeight = 1
	}

	// Parse match line range for gutter indicators
	matchStart, matchEnd := -1, -1
	if m.viewLineRange != "" {
		fmt.Sscanf(m.viewLineRange, "%d-%d", &matchStart, &matchEnd)
		matchStart-- // convert to 0-based
		matchEnd--
	}

	// Determine line number width
	maxLineNum := m.viewScroll + contentHeight
	if maxLineNum > len(m.viewLines) {
		maxLineNum = len(m.viewLines)
	}
	lineNumWidth := len(fmt.Sprintf("%d", maxLineNum))
	if lineNumWidth < 4 {
		lineNumWidth = 4
	}

	for i := 0; i < contentHeight; i++ {
		lineIdx := m.viewScroll + i
		if lineIdx >= len(m.viewLines) {
			b.WriteString("\n")
			continue
		}

		// Gutter indicator for match range
		indicator := " "
		if lineIdx >= matchStart && lineIdx <= matchEnd {
			indicator = selectedIndicator.String()
		}

		lineNum := snippetLabelStyle.Render(fmt.Sprintf("%*d", lineNumWidth, lineIdx+1))
		sep := snippetLabelStyle.Render(" │ ")

		// Get match locations for this line and render
		locs := m.viewerMatchLocsForLine(lineIdx)
		content := m.highlightWithLocs(m.viewLines[lineIdx], locs, false, m.viewProse)

		b.WriteString(indicator + lineNum + sep + content)
		b.WriteString("\n")
	}

	// === Bottom bar ===
	bottomBar := snippetLabelStyle.Render("Esc close  ↑↓ scroll  PgUp/PgDn page  Enter select")
	b.WriteString(bottomBar)

	return b.String()
}