"image"

	"strings"

// GenerateSegmentSpectrogram generates a spectrogram image for a time segment.
// Handles WAV loading, downsampling, and image creation.
// color=true applies L4 colormap, color=false creates grayscale.
// imgSize specifies the output image dimensions (clamped to [224, 896]).
func GenerateSegmentSpectrogram(dataFilePath string, startTime, endTime float64, color bool, imgSize int) (image.Image, error) {
	// Derive WAV file path (strip .data suffix)
	wavPath := strings.TrimSuffix(dataFilePath, ".data")
	// Read WAV samples
	samples, sampleRate, err := ReadWAVSamples(wavPath)
	if err != nil {
		return nil, err
	}
	// Extract segment samples
	segSamples := ExtractSegmentSamples(samples, sampleRate, startTime, endTime)
	if len(segSamples) == 0 {
		return nil, nil
	}
	// For spectrograms, downsample if sample rate exceeds 16kHz
	spectSampleRate := sampleRate
	if sampleRate > DefaultMaxSampleRate {
		segSamples = ResampleRate(segSamples, sampleRate, DefaultMaxSampleRate)
		spectSampleRate = DefaultMaxSampleRate
	}
	// Generate spectrogram
	config := DefaultSpectrogramConfig(spectSampleRate)
	spectrogram := GenerateSpectrogram(segSamples, config)
	if spectrogram == nil {
		return nil, nil
	}
	// Create image (grayscale or color)
	var img image.Image
	if color {
		colorData := ApplyL4Colormap(spectrogram)
		img = CreateRGBImage(colorData)
	} else {
		img = CreateGrayscaleImage(spectrogram)
	}
	if img == nil {
		return nil, nil
	}
	// Resize
	imgSize = ClampImageSize(imgSize)
	return ResizeImage(img, imgSize, imgSize), nil
}

	wavPath := strings.TrimSuffix(dataPath, ".data")
	samples, sampleRate, err := utils.ReadWAVSamples(wavPath)
	if err != nil {
		return nil
	}
	segSamples := utils.ExtractSegmentSamples(samples, sampleRate, seg.StartTime, seg.EndTime)
	if len(segSamples) == 0 {
		return nil
	}
	// For spectrograms, downsample if sample rate exceeds 16kHz
	spectSampleRate := sampleRate
	if sampleRate > utils.DefaultMaxSampleRate {
		segSamples = utils.ResampleRate(segSamples, sampleRate, utils.DefaultMaxSampleRate)
		spectSampleRate = utils.DefaultMaxSampleRate
	}
	config := utils.DefaultSpectrogramConfig(spectSampleRate)
	spectrogram := utils.GenerateSpectrogram(segSamples, config)
	if spectrogram == nil {
		return nil
	}
	var img image.Image
	if state.Config.Color {
		colorData := utils.ApplyL4Colormap(spectrogram)
		img = utils.CreateRGBImage(colorData)
	} else {
		img = utils.CreateGrayscaleImage(spectrogram)
	}
	if img == nil {
		return nil
	}

	imgSize = utils.ClampImageSize(imgSize)
	return utils.ResizeImage(img, imgSize, imgSize)

	img, err := utils.GenerateSegmentSpectrogram(dataPath, seg.StartTime, seg.EndTime, state.Config.Color, imgSize)
	if err != nil {
		return nil
	}
	return img

	"encoding/json"

	"image"

// Segment represents a detection segment in a .data file
type Segment struct {
	StartTime float64
	EndTime   float64
	FreqLow   float64
	FreqHigh  float64
}

	// Parse .data file
	segments, err := parseDataFile(input.DataFilePath)

	// Parse .data file (includes labels for future filtering)
	dataFile, err := utils.ParseDataFile(input.DataFilePath)

	if len(segments) == 0 {

	if len(dataFile.Segments) == 0 {

		return output, fmt.Errorf("%s", output.Error)
	}
	// Read WAV samples
	samples, sampleRate, err := utils.ReadWAVSamples(wavPath)
	if err != nil {
		output.Error = fmt.Sprintf("Failed to read WAV file: %v", err)

	imgSize = utils.ClampImageSize(imgSize)

	// For spectrograms, downsample if sample rate exceeds 16kHz
	spectSampleRate := sampleRate
	if sampleRate > utils.DefaultMaxSampleRate {
		spectSampleRate = utils.DefaultMaxSampleRate
	}

	config := utils.DefaultSpectrogramConfig(spectSampleRate)
	for i, segment := range segments {
		// Extract samples for this segment's time range
		segmentSamples := utils.ExtractSegmentSamples(samples, sampleRate, segment.StartTime, segment.EndTime)
		if len(segmentSamples) == 0 {
			continue
		}
		// Downsample for spectrogram if needed
		if sampleRate > utils.DefaultMaxSampleRate {
			segmentSamples = utils.ResampleRate(segmentSamples, sampleRate, utils.DefaultMaxSampleRate)
		}
		// Generate spectrogram
		spectrogram := utils.GenerateSpectrogram(segmentSamples, config)
		if spectrogram == nil {
			continue
		}
		// Print segment time info and spectrogram dimensions
		fmt.Fprintf(os.Stderr, "Segment %d: %.1fs - %.1fs (%.1fs)  spectrogram: %dx%d\n", i+1, segment.StartTime, segment.EndTime, segment.EndTime-segment.StartTime, len(spectrogram[0]), len(spectrogram))
		// Create image (grayscale or color)
		var img image.Image
		if input.Color {
			// Apply L4 colormap
			colorData := utils.ApplyL4Colormap(spectrogram)
			img = utils.CreateRGBImage(colorData)
		} else {
			img = utils.CreateGrayscaleImage(spectrogram)
		}
		if img == nil {

	for i, seg := range dataFile.Segments {
		// Generate spectrogram image
		img, err := utils.GenerateSegmentSpectrogram(input.DataFilePath, seg.StartTime, seg.EndTime, input.Color, imgSize)
		if err != nil || img == nil {

		resized := utils.ResizeImage(img, imgSize, imgSize)

		// Print segment info
		labelInfo := formatSegmentLabels(seg.Labels)
		fmt.Fprintf(os.Stderr, "Segment %d: %.1fs - %.1fs (%.1fs)%s\n",
			i+1, seg.StartTime, seg.EndTime, seg.EndTime-seg.StartTime, labelInfo)

		if err := utils.WriteImage(resized, os.Stdout, protocol); err != nil {

		if err := utils.WriteImage(img, os.Stdout, protocol); err != nil {

	output.SegmentsShown = len(segments)

	output.SegmentsShown = len(dataFile.Segments)

// parseDataFile parses an AviaNZ .data file and extracts segments
func parseDataFile(path string) ([]Segment, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, fmt.Errorf("failed to open .data file: %v", err)
	}
	defer file.Close()

	// Parse JSON array
	var data []any
	decoder := json.NewDecoder(file)
	if err := decoder.Decode(&data); err != nil {
		return nil, fmt.Errorf("failed to parse .data file: %v", err)

// formatSegmentLabels formats labels for display in segment info
func formatSegmentLabels(labels []*utils.Label) string {
	if len(labels) == 0 {
		return ""

	// First element is metadata, rest are segments
	if len(data) < 2 {
		return nil, nil
	}
	var segments []Segment
	for i := 1; i < len(data); i++ {
		seg, ok := data[i].([]any)
		if !ok || len(seg) < 5 {
			continue

	var parts []string
	for _, l := range labels {
		part := l.Species
		if l.CallType != "" {
			part += "/" + l.CallType

		// Parse segment: [start_time, end_time, freq_low, freq_high, labels]
		startTime, ok1 := seg[0].(float64)
		endTime, ok2 := seg[1].(float64)
		freqLow, ok3 := seg[2].(float64)
		freqHigh, ok4 := seg[3].(float64)
		if !ok1 || !ok2 || !ok3 || !ok4 {
			continue

		if l.Filter != "" {
			part += " [" + l.Filter + "]"

		segments = append(segments, Segment{
			StartTime: startTime,
			EndTime:   endTime,
			FreqLow:   freqLow,
			FreqHigh:  freqHigh,
		})

		parts = append(parts, part)

	return segments, nil

	return "  " + strings.Join(parts, ", ")

## [2026-04-02] Shared spectrogram generation for show-images and classify
Refactored spectrogram image generation into a shared utility function, reducing
duplication between `calls show-images` and `calls classify` TUI.
**New utility:**
- `utils.GenerateSegmentSpectrogram(dataFilePath, startTime, endTime, color, imgSize)` - 
  generates a spectrogram image from a segment, handling WAV loading, downsampling,
  and image creation in one call.
**Changes:**
- `utils/spectrogram.go` — Added `GenerateSegmentSpectrogram()` function
- `tools/calls_show_images.go` — Now uses `utils.ParseDataFile()` (includes labels) and
  `GenerateSegmentSpectrogram()`; removed local `Segment` struct and `parseDataFile()`;
  segment info now shows labels when present
- `tui/classify.go` — `generateSpectrogramImage()` now delegates to shared function

**Future:** show-images now has access to segment labels, enabling future filtering
by filter/ml model and species+calltype.