"bufio"

	w := bufio.NewWriterSize(file, 64*1024)

	// Write RIFF header
	if _, err := file.WriteString("RIFF"); err != nil {
		return err
	}
	if err := binary.Write(file, binary.LittleEndian, uint32(totalSize)); err != nil {
		return err
	}
	if _, err := file.WriteString("WAVE"); err != nil {
		return err
	}

	// Write 44-byte WAV header in one go
	header := make([]byte, 44)
	copy(header[0:4], "RIFF")
	binary.LittleEndian.PutUint32(header[4:8], uint32(totalSize))
	copy(header[8:12], "WAVE")
	copy(header[12:16], "fmt ")
	binary.LittleEndian.PutUint32(header[16:20], 16) // chunk size
	binary.LittleEndian.PutUint16(header[20:22], 1)  // PCM format
	binary.LittleEndian.PutUint16(header[22:24], uint16(channels))
	binary.LittleEndian.PutUint32(header[24:28], uint32(sampleRate))
	binary.LittleEndian.PutUint32(header[28:32], uint32(byteRate))
	binary.LittleEndian.PutUint16(header[32:34], uint16(blockAlign))
	binary.LittleEndian.PutUint16(header[34:36], uint16(bitsPerSample))
	copy(header[36:40], "data")
	binary.LittleEndian.PutUint32(header[40:44], uint32(dataSize))

	// Write fmt chunk
	if _, err := file.WriteString("fmt "); err != nil {

	if _, err := w.Write(header); err != nil {

	if err := binary.Write(file, binary.LittleEndian, uint32(16)); err != nil { // chunk size
		return err
	}
	if err := binary.Write(file, binary.LittleEndian, uint16(1)); err != nil { // PCM format
		return err
	}
	if err := binary.Write(file, binary.LittleEndian, uint16(channels)); err != nil {
		return err
	}
	if err := binary.Write(file, binary.LittleEndian, uint32(sampleRate)); err != nil {
		return err
	}
	if err := binary.Write(file, binary.LittleEndian, uint32(byteRate)); err != nil {
		return err
	}
	if err := binary.Write(file, binary.LittleEndian, uint16(blockAlign)); err != nil {
		return err
	}
	if err := binary.Write(file, binary.LittleEndian, uint16(bitsPerSample)); err != nil {
		return err
	}
	// Write data chunk header
	if _, err := file.WriteString("data"); err != nil {
		return err
	}
	if err := binary.Write(file, binary.LittleEndian, uint32(dataSize)); err != nil {
		return err
	}

	// Convert float64 samples to 16-bit PCM and write
	for _, sample := range samples {

	// Convert all float64 samples to 16-bit PCM in a single buffer
	buf := make([]byte, dataSize)
	for i, sample := range samples {

		// Convert to 16-bit signed integer
		value := int16(sample * 32767)
		if err := binary.Write(file, binary.LittleEndian, value); err != nil {
			return err
		}

		binary.LittleEndian.PutUint16(buf[i*2:], uint16(int16(sample*32767)))
	}
	if _, err := w.Write(buf); err != nil {
		return err

	return nil

	return w.Flush()

		for x := range width {
			img.SetGray(x, y, color.Gray{Y: data[y][x]})
		}

		off := y * img.Stride
		row := data[y]
		copy(img.Pix[off:off+width], row)

		off := y * img.Stride
		row := data[y]

			img.SetRGBA(x, y, color.RGBA{
				R: data[y][x].R,
				G: data[y][x].G,
				B: data[y][x].B,
				A: 255,
			})

			i := off + x*4
			img.Pix[i] = row[x].R
			img.Pix[i+1] = row[x].G
			img.Pix[i+2] = row[x].B
			img.Pix[i+3] = 255

	// Detect if image is grayscale or RGB
	_, isGray := img.(*image.Gray)

	if isGray {

	if srcGray, ok := img.(*image.Gray); ok {

			srcY := int(float64(y) * scaleY)
			if srcY >= srcHeight {
				srcY = srcHeight - 1
			}
			dstOff := y * result.Stride
			srcRowOff := srcY * srcGray.Stride

				srcY := int(float64(y) * scaleY)

				if srcX >= srcWidth {
					srcX = srcWidth - 1
				}
				result.Pix[dstOff+x] = srcGray.Pix[srcRowOff+srcX]
			}
		}
		return result
	}

	if srcRGBA, ok := img.(*image.RGBA); ok {
		result := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
		for y := range newHeight {
			srcY := int(float64(y) * scaleY)
			if srcY >= srcHeight {
				srcY = srcHeight - 1
			}
			dstOff := y * result.Stride
			srcRowOff := srcY * srcRGBA.Stride
			for x := range newWidth {
				srcX := int(float64(x) * scaleX)

				if srcY >= srcHeight {
					srcY = srcHeight - 1
				}
				c := img.At(srcX+bounds.Min.X, srcY+bounds.Min.Y)
				gray := color.GrayModel.Convert(c).(color.Gray)
				result.SetGray(x, y, gray)

				si := srcRowOff + srcX*4
				di := dstOff + x*4
				result.Pix[di] = srcRGBA.Pix[si]
				result.Pix[di+1] = srcRGBA.Pix[si+1]
				result.Pix[di+2] = srcRGBA.Pix[si+2]
				result.Pix[di+3] = srcRGBA.Pix[si+3]

	// Fallback for other image types

		srcY := int(float64(y) * scaleY)
		if srcY >= srcHeight {
			srcY = srcHeight - 1
		}

			srcY := int(float64(y) * scaleY)

			if srcY >= srcHeight {
				srcY = srcHeight - 1
			}

// WritePNG writes an image to a writer in PNG format.

// WritePNG writes an image to a writer in PNG format using fast compression.

	return png.Encode(w, img)

	enc := &png.Encoder{CompressionLevel: png.BestSpeed}
	return enc.Encode(w, img)

	"sync"

// cached Hann windows by size, computed once
var (
	hannCache   = map[int][]float64{}
	hannCacheMu sync.RWMutex
)
func init() {
	// Pre-compute radix-2 factors for default window size to avoid lock contention under parallelism
	fft.EnsureRadix2Factors(512)
}
// getCachedHannWindow returns a cached Hann window of the given size.
func getCachedHannWindow(size int) []float64 {
	hannCacheMu.RLock()
	if w, ok := hannCache[size]; ok {
		hannCacheMu.RUnlock()
		return w
	}
	hannCacheMu.RUnlock()

	hannCacheMu.Lock()
	defer hannCacheMu.Unlock()
	// Double-check after acquiring write lock
	if w, ok := hannCache[size]; ok {
		return w
	}
	w := window.Hann(size)
	hannCache[size] = w
	return w
}

		WindowSize: 400,
		HopSize:    200, // 50% overlap (window/2)

		WindowSize: 512,
		HopSize:    256, // 50% overlap (window/2)

	// Generate Hann window
	hannWindow := window.Hann(cfg.WindowSize)

	// Get cached Hann window
	hannWindow := getCachedHannWindow(cfg.WindowSize)

	// Allocate power spectrum matrix (freq bins x time frames)
	powerMatrix := make([][]float64, numFreqBins)
	for i := range powerMatrix {
		powerMatrix[i] = make([]float64, numFrames)
	}

	// Allocate power spectrum as flat backing slice (single allocation)
	powerFlat := make([]float64, numFreqBins*numFrames)

		// Compute power spectrum (magnitude squared)

		// Compute power spectrum (magnitude squared) into flat slice

			power := re*re + im*im
			powerMatrix[bin][frame] = power

			powerFlat[bin*numFrames+frame] = re*re + im*im

	// Handle zeros (replace with smallest non-zero value)
	replaceZeros(powerMatrix)
	// Convert to dB, normalize, and convert to uint8
	return normalizeToUint8(powerMatrix)

	// Fused normalization: replace zeros, convert to dB, find min/max, normalize to uint8
	// All in 2 passes instead of 6
	return normalizeFlat(powerFlat, numFreqBins, numFrames)

// replaceZeros replaces zero values with the smallest non-zero value
func replaceZeros(matrix [][]float64) {
	// Find smallest non-zero value
	minNonZero := math.MaxFloat64
	for _, row := range matrix {
		for _, val := range row {
			if val > 0 && val < minNonZero {
				minNonZero = val
			}
		}

// normalizeFlat converts power values to dB, normalizes to 0-255, in 2 passes.
// Operates on a flat slice laid out as [row0_col0, row0_col1, ..., row1_col0, ...].
// Returns [][]uint8 with rows flipped vertically (low frequencies at bottom).
func normalizeFlat(power []float64, rows, cols int) [][]uint8 {
	if rows == 0 || cols == 0 {
		return nil

	// Replace zeros
	if minNonZero != math.MaxFloat64 {
		for i, row := range matrix {
			for j, val := range row {
				if val == 0 {
					matrix[i][j] = minNonZero
				}
			}

	// Pass 1: find minNonZero, then convert power to dB in-place, tracking min/max dB
	minNonZero := math.MaxFloat64
	for _, val := range power {
		if val > 0 && val < minNonZero {
			minNonZero = val

}
// normalizeToUint8 converts power to dB, normalizes to 0-255
func normalizeToUint8(powerMatrix [][]float64) [][]uint8 {
	rows := len(powerMatrix)
	if rows == 0 {
		return nil

	if minNonZero == math.MaxFloat64 {
		minNonZero = 1e-20 // fallback floor

	cols := len(powerMatrix[0])

	// Convert to dB and find min/max
	dbMatrix := make([][]float64, rows)
	for i := range dbMatrix {
		dbMatrix[i] = make([]float64, cols)
	}

	for i, row := range powerMatrix {
		for j, power := range row {
			// Power to dB: 10 * log10(power)
			db := 10.0 * math.Log10(power)
			dbMatrix[i][j] = db
			if db < minDB {
				minDB = db
			}
			if db > maxDB {
				maxDB = db
			}

	for i, val := range power {
		if val <= 0 {
			val = minNonZero

	}
	// Normalize to 0-255
	result := make([][]uint8, rows)
	for i := range result {
		result[i] = make([]uint8, cols)

		db := 10.0 * math.Log10(val)
		power[i] = db
		if db < minDB {
			minDB = db
		}
		if db > maxDB {
			maxDB = db
		}

	// Pass 2: normalize dB to uint8 and write into result (with vertical flip)

		rangeDB = 1 // Avoid division by zero

		rangeDB = 1

	scale := 255.0 / rangeDB

	for i, row := range dbMatrix {
		for j, db := range row {
			// Shift to non-negative, normalize to 0-1, then to 0-255
			normalized := (db - minDB) / rangeDB
			result[i][j] = uint8(normalized * 255.0)

	// Allocate result with flat backing slice (single allocation)
	resultFlat := make([]uint8, rows*cols)
	result := make([][]uint8, rows)
	for i := range result {
		// Flip: row i in result gets data from row (rows-1-i) in power
		srcRow := rows - 1 - i
		result[i] = resultFlat[i*cols : (i+1)*cols]
		srcOff := srcRow * cols
		for j := range cols {
			result[i][j] = uint8((power[srcOff+j] - minDB) * scale)

	// Flip vertically (low frequencies at bottom)
	flipVertical(result)

}
// flipVertical flips the matrix vertically
func flipVertical(matrix [][]uint8) {
	rows := len(matrix)
	for i := 0; i < rows/2; i++ {
		matrix[i], matrix[rows-1-i] = matrix[rows-1-i], matrix[i]
	}

	"runtime"

	"sync"

	// Process each .data file
	for _, dataPath := range filePaths {
		clips, errs := processFile(dataPath, input.Output, input.Prefix, input.Filter, speciesName, callType, input.Certainty, imgSize, input.Color)
		output.SegmentsClipped += len(clips)
		output.OutputFiles = append(output.OutputFiles, clips...)
		output.Errors = append(output.Errors, errs...)
		if len(clips) > 0 || len(errs) == 0 {
			output.FilesProcessed++

	// Process .data files (parallel for larger batches)
	if len(filePaths) <= 2 {
		// Sequential for small batches
		for _, dataPath := range filePaths {
			clips, errs := processFile(dataPath, input.Output, input.Prefix, input.Filter, speciesName, callType, input.Certainty, imgSize, input.Color)
			output.SegmentsClipped += len(clips)
			output.OutputFiles = append(output.OutputFiles, clips...)
			output.Errors = append(output.Errors, errs...)
			if len(clips) > 0 || len(errs) == 0 {
				output.FilesProcessed++
			}
		}
	} else {
		// Parallel file processing
		type fileResult struct {
			clips []string
			errs  []string
		}
		workers := min(runtime.NumCPU(), 8, len(filePaths))
		jobs := make(chan string, len(filePaths))
		results := make(chan fileResult, len(filePaths))
		var wg sync.WaitGroup
		for range workers {
			wg.Add(1)
			go func() {
				defer wg.Done()
				for dataPath := range jobs {
					clips, errs := processFile(dataPath, input.Output, input.Prefix, input.Filter, speciesName, callType, input.Certainty, imgSize, input.Color)
					results <- fileResult{clips: clips, errs: errs}
				}
			}()
		}
		for _, dataPath := range filePaths {
			jobs <- dataPath
		}
		close(jobs)
		go func() {
			wg.Wait()
			close(results)
		}()
		for r := range results {
			output.SegmentsClipped += len(r.clips)
			output.OutputFiles = append(output.OutputFiles, r.clips...)
			output.Errors = append(output.Errors, r.errs...)
			if len(r.clips) > 0 || len(r.errs) == 0 {
				output.FilesProcessed++
			}

	// Process each matching segment
	for _, seg := range matchingSegments {
		clipFiles, err := generateClip(samples, sampleRate, outputDir, prefix, basename, seg.StartTime, seg.EndTime, imgSize, color)
		if err != nil {
			errors = append(errors, fmt.Sprintf("%s: segment %.0f-%.0f: %v", dataPath, seg.StartTime, seg.EndTime, err))
			continue

	// Process matching segments (parallel for larger batches)
	if len(matchingSegments) <= 2 {
		for _, seg := range matchingSegments {
			clipFiles, err := generateClip(samples, sampleRate, outputDir, prefix, basename, seg.StartTime, seg.EndTime, imgSize, color)
			if err != nil {
				errors = append(errors, fmt.Sprintf("%s: segment %.0f-%.0f: %v", dataPath, seg.StartTime, seg.EndTime, err))
				continue
			}
			clips = append(clips, clipFiles...)

		clips = append(clips, clipFiles...)

	} else {
		type segResult struct {
			clips []string
			err   string
		}
		workers := min(runtime.NumCPU(), len(matchingSegments))
		jobs := make(chan *utils.Segment, len(matchingSegments))
		results := make(chan segResult, len(matchingSegments))
		var wg sync.WaitGroup
		for range workers {
			wg.Add(1)
			go func() {
				defer wg.Done()
				for seg := range jobs {
					clipFiles, err := generateClip(samples, sampleRate, outputDir, prefix, basename, seg.StartTime, seg.EndTime, imgSize, color)
					if err != nil {
						results <- segResult{err: fmt.Sprintf("%s: segment %.0f-%.0f: %v", dataPath, seg.StartTime, seg.EndTime, err)}
					} else {
						results <- segResult{clips: clipFiles}
					}
				}
			}()
		}
		for _, seg := range matchingSegments {
			jobs <- seg
		}
		close(jobs)
		go func() {
			wg.Wait()
			close(results)
		}()
		for r := range results {
			if r.err != "" {
				errors = append(errors, r.err)
			} else {
				clips = append(clips, r.clips...)
			}
		}

	// Check if files already exist
	if _, err := os.Stat(pngPath); err == nil {
		return nil, fmt.Errorf("file already exists: %s", pngPath)
	}
	if _, err := os.Stat(wavPath); err == nil {
		return nil, fmt.Errorf("file already exists: %s", wavPath)
	}

	// Write PNG
	pngFile, err := os.Create(pngPath)

	// Write PNG (O_EXCL fails atomically if file exists, replacing os.Stat check)
	pngFile, err := os.OpenFile(pngPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)

		if os.IsExist(err) {
			return nil, fmt.Errorf("file already exists: %s", pngPath)
		}