"path/filepath"

	// Clip dialog state
	clipMode  bool   // true when clip dialog is open
	clipInput string // current prefix input

	// If in clip mode, route to clip handler
	if m.clipMode {
		return m.handleClipKey(msg)
	}

		return m, nil
	}
	// Check for Ctrl+S (save clip dialog)
	if msg.String() == "ctrl+s" {
		m.clipInput = ""
		m.clipMode = true

		}
		return m, nil
	}
	return m, nil
}
// handleClipKey handles key presses in clip mode
func (m Model) handleClipKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	key := msg.Key()
	// Enter: save clip
	if key.Code == tea.KeyEnter {
		if m.clipInput == "" {
			m.clipMode = false
			return m, nil
		}
		// Save the clip
		err := saveClip(m.state, m.clipInput)
		if err != nil {
			m.err = err.Error()
		} else {
			m.err = "Clip saved: " + m.clipInput
		}
		m.clipMode = false
		return m, nil
	}
	// Escape: cancel
	if key.Code == tea.KeyEscape || key.Code == tea.KeyEsc {
		m.clipMode = false
		return m, nil
	}
	// Backspace: remove last character
	if key.Code == tea.KeyBackspace {
		if len(m.clipInput) > 0 {
			m.clipInput = m.clipInput[:len(m.clipInput)-1]

	// Printable characters: append to input
	s := msg.String()
	if len(s) == 1 && s[0] >= 32 && s[0] <= 126 { // printable ASCII
		if len(m.clipInput) < 64 {
			m.clipInput += s
		}
		return m, nil
	}

// saveClip saves a clip of the current segment to the current working directory
func saveClip(state *tools.ClassifyState, prefix string) error {
	df := state.CurrentFile()
	seg := state.CurrentSegment()
	if df == nil || seg == nil {
		return fmt.Errorf("no segment selected")
	}
	// Get WAV path
	wavPath := strings.TrimSuffix(df.FilePath, ".data")
	// Get basename without path and extension
	basename := wavPath[strings.LastIndex(wavPath, "/")+1:]
	basename = strings.TrimSuffix(basename, ".wav")

	// Calculate integer times for filename
	startInt := int(seg.StartTime)
	endInt := int(seg.EndTime)
	if seg.EndTime > float64(endInt) {
		endInt++ // ceil
	}
	// Build output paths (current working directory)
	cwd, err := os.Getwd()
	if err != nil {
		return fmt.Errorf("failed to get working directory: %w", err)
	}
	baseName := fmt.Sprintf("%s_%s_%d_%d", prefix, basename, startInt, endInt)
	pngPath := filepath.Join(cwd, baseName+".png")
	wavOutPath := filepath.Join(cwd, baseName+".wav")
	// Check if files already exist
	if _, err := os.Stat(pngPath); err == nil {
		return fmt.Errorf("file already exists: %s", pngPath)
	}
	if _, err := os.Stat(wavOutPath); err == nil {
		return fmt.Errorf("file already exists: %s", wavOutPath)
	}
	// Read WAV samples
	samples, sampleRate, err := utils.ReadWAVSamples(wavPath)
	if err != nil {
		return fmt.Errorf("failed to read WAV: %w", err)
	}
	// Extract segment samples
	segSamples := utils.ExtractSegmentSamples(samples, sampleRate, seg.StartTime, seg.EndTime)
	if len(segSamples) == 0 {
		return fmt.Errorf("no samples in segment")
	}
	// Determine output sample rate (downsample if > 16kHz)
	outputSampleRate := sampleRate
	if sampleRate > utils.DefaultMaxSampleRate {
		segSamples = utils.ResampleRate(segSamples, sampleRate, utils.DefaultMaxSampleRate)
		outputSampleRate = utils.DefaultMaxSampleRate
	}
	// Generate spectrogram (224px, color)
	config := utils.DefaultSpectrogramConfig(outputSampleRate)
	spectrogram := utils.GenerateSpectrogram(segSamples, config)
	if spectrogram == nil {
		return fmt.Errorf("failed to generate spectrogram")
	}
	colorData := utils.ApplyL4Colormap(spectrogram)
	img := utils.CreateRGBImage(colorData)
	if img == nil {
		return fmt.Errorf("failed to create image")
	}
	resized := utils.ResizeImage(img, 224, 224)
	// Write PNG
	pngFile, err := os.Create(pngPath)
	if err != nil {
		return fmt.Errorf("failed to create PNG: %w", err)
	}
	if err := utils.WritePNG(resized, pngFile); err != nil {
		pngFile.Close()
		return fmt.Errorf("failed to write PNG: %w", err)
	}
	pngFile.Close()
	// Write WAV
	if err := utils.WriteWAVFile(wavOutPath, segSamples, outputSampleRate); err != nil {
		return fmt.Errorf("failed to write WAV: %w", err)
	}
	return nil
}

	b.WriteString(helpDarkStyle.Render(wrapText("[esc]quit [,]prev [.]next [space]comment [ctrl+g]goto [ctrl+d]bookmark [ctrl+,]prev-bk [ctrl+.]next-bk [enter]play [shift+enter]½speed", wrapWidth)))

	b.WriteString(helpDarkStyle.Render(wrapText("[esc]quit [,]prev [.]next [space]comment [ctrl+s]clip [ctrl+g]goto [ctrl+d]bookmark [ctrl+,]prev-bk [ctrl+.]next-bk [enter]play [shift+enter]½speed", wrapWidth)))

	// Clip dialog (when active)
	if m.clipMode {
		m.renderClipDialog(&b)
		return tea.NewView(b.String())
	}

// renderClipDialog renders the clip prefix input dialog
func (m Model) renderClipDialog(b *strings.Builder) {
	inputLine := m.clipInput + "█"
	helpLine := "[enter]save  [esc]cancel"
	// Render box
	content := fmt.Sprintf("Clip prefix:\n%s\n%s", inputLine, helpLine)
	b.WriteString(commentBoxStyle.Render(content))
}

## [2026-04-02] Clip feature in `calls classify` TUI
Added `ctrl+s` keybinding to save a clip of the current segment directly from
the classification TUI.
**Keybinding:** `ctrl+s` → type prefix → `enter` to save, `esc` to cancel
**Output files:**
- `<prefix>_<basename>_<start>_<end>.png` — 224x224 color spectrogram (L4 colormap)
- `<prefix>_<basename>_<start>_<end>.wav` — audio clip (16kHz if downsampled)

Files are saved to the current working directory where `skraak` was launched.
Error if files already exist (no overwrite).
**Changes:**
- `tui/classify.go` — Added `clipMode` state, `handleClipKey()`, `renderClipDialog()`,
  and `saveClip()` function; added `ctrl+s` keybinding; updated help line