quietlight/skraakCLI - Change XU7FTYK3YAM5TADBGEJZ44UJ6LNJ7YVABSFEXKOBGUHXBFHVLR2AC

third phase of utils refactor, wav/

Created by quietlight on May 18, 2026

XU7FTYK3YAM5TADBGEJZ44UJ6LNJ7YVABSFEXKOBGUHXBFHVLR2AC

Dependencies

In channels

main

Change contents

File addition: wav (d--x------)
[4.1]

File addition: wav_writer_test.go (----------)

[0.1]

package wav
import (
	"os"
	"path/filepath"
	"testing"
)
func TestWriteWAVFile(t *testing.T) {
	t.Run("writes valid samples", func(t *testing.T) {
		path := filepath.Join(t.TempDir(), "test.wav")
		samples := []float64{0.5, -0.5, 1.5, -1.5} // includes out of bounds for clamping
		err := WriteWAVFile(path, samples, 8000)
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		info, err := os.Stat(path)
		if err != nil || info.Size() == 0 {
			t.Error("expected file to be written with data")
		}
	})
	t.Run("fails on empty samples", func(t *testing.T) {
		path := filepath.Join(t.TempDir(), "empty.wav")
		err := WriteWAVFile(path, []float64{}, 8000)
		if err == nil {
			t.Error("expected error for empty samples")
		}
	})
}

File addition: wav_writer.go (----------)

[0.1]

package wav
import (
	"bufio"
	"encoding/binary"
	"fmt"
	"os"
	"skraak/audio"
)
// WriteWAVFile writes audio samples to a WAV file.
// Samples should be in the range -1.0 to 1.0.
// Output is mono 16-bit PCM.
func WriteWAVFile(filepath string, samples []float64, sampleRate int) error {
	if len(samples) == 0 {
		return fmt.Errorf("no samples to write")
	}
	file, err := os.Create(filepath)
	if err != nil {
		return fmt.Errorf("failed to create file: %w", err)
	}
	w := bufio.NewWriterSize(file, 64*1024)
	// Write WAV and flush; check close to ensure data is persisted.
	err = func() error {
		// WAV parameters
		channels := 1
		bitsPerSample := 16
		bytesPerSample := bitsPerSample / 8
		byteRate := sampleRate * channels * bytesPerSample
		blockAlign := channels * bytesPerSample
		dataSize := len(samples) * bytesPerSample
		totalSize := 36 + dataSize // 36 = header size before data chunk
		// 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))
		if _, err := w.Write(header); err != nil {
			return err
		}
		// Convert all float64 samples to 16-bit PCM in a single buffer
		buf := audio.Float64ToPCM16(samples)
		if _, err := w.Write(buf); err != nil {
			return err
		}
		return w.Flush()
	}()
	if err2 := file.Close(); err2 != nil {
		if err == nil {
			err = fmt.Errorf("failed to close file: %w", err2)
		}
	}
	return err
}

File addition: wav_metadata_test.go (----------)

[0.1]

package wav
import (
	"bytes"
	"encoding/binary"
	"fmt"
	"math"
	"os"
	"path/filepath"
	"testing"
	"time"
)
// createTestWAVFile creates a minimal valid WAV file for testing
func createTestWAVFile(t *testing.T, dir string, filename string, options struct {
	duration      float64
	sampleRate    int
	channels      int
	bitsPerSample int
	comment       string
	artist        string
}) string {
	t.Helper()
	path := filepath.Join(dir, filename)
	file, err := os.Create(path)
	if err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}
	defer file.Close()
	// Calculate data chunk size based on duration
	bytesPerSample := options.bitsPerSample / 8
	samplesPerSecond := options.sampleRate * options.channels
	dataSize := int(options.duration * float64(samplesPerSecond*bytesPerSample))
	// Calculate file size (excluding RIFF header)
	fileSize := 4 + 8 + 16 + 8 + dataSize // WAVE + fmt chunk + data chunk header
	// Add LIST INFO chunk size if metadata provided
	var infoChunk []byte
	if options.comment != "" || options.artist != "" {
		infoChunk = buildINFOChunk(options.comment, options.artist)
		fileSize += 8 + len(infoChunk) // LIST chunk header + content
	}
	buf := &bytes.Buffer{}
	// Write RIFF header
	buf.WriteString("RIFF")
	binary.Write(buf, binary.LittleEndian, uint32(fileSize))
	buf.WriteString("WAVE")
	// Write fmt chunk
	buf.WriteString("fmt ")
	binary.Write(buf, binary.LittleEndian, uint32(16)) // chunk size
	binary.Write(buf, binary.LittleEndian, uint16(1))  // audio format (PCM)
	binary.Write(buf, binary.LittleEndian, uint16(options.channels))
	binary.Write(buf, binary.LittleEndian, uint32(options.sampleRate))
	byteRate := options.sampleRate * options.channels * bytesPerSample
	binary.Write(buf, binary.LittleEndian, uint32(byteRate))
	blockAlign := options.channels * bytesPerSample
	binary.Write(buf, binary.LittleEndian, uint16(blockAlign))
	binary.Write(buf, binary.LittleEndian, uint16(options.bitsPerSample))
	// Write LIST INFO chunk if metadata provided
	if len(infoChunk) > 0 {
		buf.WriteString("LIST")
		binary.Write(buf, binary.LittleEndian, uint32(len(infoChunk)))
		buf.Write(infoChunk)
	}
	// Write data chunk
	buf.WriteString("data")
	binary.Write(buf, binary.LittleEndian, uint32(dataSize))
	// Write silence for data
	buf.Write(make([]byte, dataSize))
	// Write to file
	if _, err := file.Write(buf.Bytes()); err != nil {
		t.Fatalf("Failed to write test file: %v", err)
	}
	return path
}
// buildINFOChunk builds a LIST INFO chunk with optional comment and artist
func buildINFOChunk(comment, artist string) []byte {
	buf := &bytes.Buffer{}
	buf.WriteString("INFO")
	if comment != "" {
		buf.WriteString("ICMT")
		// Size includes null terminator
		size := len(comment) + 1
		binary.Write(buf, binary.LittleEndian, uint32(size))
		buf.WriteString(comment)
		buf.WriteByte(0) // null terminator
		// Add padding byte if needed for word alignment
		if size%2 != 0 {
			buf.WriteByte(0)
		}
	}
	if artist != "" {
		buf.WriteString("IART")
		size := len(artist) + 1
		binary.Write(buf, binary.LittleEndian, uint32(size))
		buf.WriteString(artist)
		buf.WriteByte(0) // null terminator
		if size%2 != 0 {
			buf.WriteByte(0)
		}
	}
	return buf.Bytes()
}
func TestConvertToFloat64_16Bit(t *testing.T) {
	// 16-bit signed, little-endian: 0x0001 = 1 → 1/32768
	data := []byte{0x01, 0x00, 0xFF, 0x7F}
	samples := convertToFloat64(data, 16, 1)
	if len(samples) != 2 {
		t.Fatalf("expected 2 samples, got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/32768.0) > 1e-10 {
		t.Errorf("sample[0] = %v, want %v", samples[0], 1.0/32768.0)
	}
	// 0x7FFF = 32767 → 32767/32768 ≈ 0.99997
	if math.Abs(samples[1]-32767.0/32768.0) > 1e-10 {
		t.Errorf("sample[1] = %v, want %v", samples[1], 32767.0/32768.0)
	}
}
func TestConvertToFloat64_16BitNegative(t *testing.T) {
	// 0x8000 = -32768 → -32768/32768 = -1.0
	data := []byte{0x00, 0x80}
	samples := convertToFloat64(data, 16, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-(-1.0)) > 1e-10 {
		t.Errorf("sample = %v, want -1.0", samples[0])
	}
}
func TestConvertToFloat64_16BitStereo(t *testing.T) {
	// Stereo: should extract only left channel
	// Left: 0x0001 = 1, Right: 0x0002 = 2
	data := []byte{0x01, 0x00, 0x02, 0x00}
	samples := convertToFloat64(data, 16, 2)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample (left only), got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/32768.0) > 1e-10 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/32768.0)
	}
}
func TestConvertToFloat64_24Bit(t *testing.T) {
	// 24-bit signed, little-endian: 0x000001 = 1 → 1/8388608
	data := []byte{0x01, 0x00, 0x00}
	samples := convertToFloat64(data, 24, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/8388608.0) > 1e-12 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/8388608.0)
	}
}
func TestConvertToFloat64_24BitNegative(t *testing.T) {
	// 24-bit: 0xFFFFFF = -1 (sign extended) → -1/8388608
	data := []byte{0xFF, 0xFF, 0xFF}
	samples := convertToFloat64(data, 24, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-(-1.0/8388608.0)) > 1e-12 {
		t.Errorf("sample = %v, want %v", samples[0], -1.0/8388608.0)
	}
}
func TestConvertToFloat64_24BitMaxPositive(t *testing.T) {
	// 24-bit max positive: 0x7FFFFF = 8388607 → ~0.9999999
	data := []byte{0xFF, 0xFF, 0x7F}
	samples := convertToFloat64(data, 24, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-8388607.0/8388608.0) > 1e-12 {
		t.Errorf("sample = %v, want %v", samples[0], 8388607.0/8388608.0)
	}
}
func TestConvertToFloat64_24BitMinNegative(t *testing.T) {
	// 24-bit min negative: 0x800000 = -8388608 → -1.0
	data := []byte{0x00, 0x00, 0x80}
	samples := convertToFloat64(data, 24, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-(-1.0)) > 1e-12 {
		t.Errorf("sample = %v, want -1.0", samples[0])
	}
}
func TestConvertToFloat64_24BitStereo(t *testing.T) {
	// 24-bit stereo: left=0x000001=1, right=0x000002=2
	data := []byte{0x01, 0x00, 0x00, 0x02, 0x00, 0x00}
	samples := convertToFloat64(data, 24, 2)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample (left only), got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/8388608.0) > 1e-12 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/8388608.0)
	}
}
func TestConvertToFloat64_32Bit(t *testing.T) {
	// 32-bit signed, little-endian: 0x00000001 = 1 → 1/2147483648
	data := []byte{0x01, 0x00, 0x00, 0x00}
	samples := convertToFloat64(data, 32, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/2147483648.0) > 1e-15 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/2147483648.0)
	}
}
func TestConvertToFloat64_32BitNegative(t *testing.T) {
	// 32-bit: 0x80000000 = -2147483648 → -1.0
	data := []byte{0x00, 0x00, 0x00, 0x80}
	samples := convertToFloat64(data, 32, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-(-1.0)) > 1e-15 {
		t.Errorf("sample = %v, want -1.0", samples[0])
	}
}
func TestConvertToFloat64_32BitMaxPositive(t *testing.T) {
	// 32-bit max positive: 0x7FFFFFFF = 2147483647 → ~0.9999999995
	data := []byte{0xFF, 0xFF, 0xFF, 0x7F}
	samples := convertToFloat64(data, 32, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-2147483647.0/2147483648.0) > 1e-15 {
		t.Errorf("sample = %v, want %v", samples[0], 2147483647.0/2147483648.0)
	}
}
func TestConvertToFloat64_32BitStereo(t *testing.T) {
	// 32-bit stereo: left=1, right=2
	data := []byte{0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00}
	samples := convertToFloat64(data, 32, 2)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample (left only), got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/2147483648.0) > 1e-15 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/2147483648.0)
	}
}
func TestConvertToFloat64_UnsupportedBitDepth(t *testing.T) {
	// Unsupported bit depth (8) falls back to 16-bit parsing.
	// blockAlign = (8/8)*1 = 1, so numSamples = len(data)/1 = 4.
	// But 16-bit reads 2 bytes per sample, which panics with only 1 byte per block.
	// This tests the fallback path exists; for valid 8-bit data, blockAlign
	// must be 2 (so 2 bytes per sample in the data layout).
	data := []byte{0x01, 0x00, 0x02, 0x00}  // 4 bytes, treated as 2x 16-bit samples
	samples := convertToFloat64(data, 8, 2) // 2 channels → blockAlign = 1*2 = 2
	if len(samples) != 2 {
		t.Fatalf("expected 2 samples (fallback 16-bit), got %d", len(samples))
	}
}
func TestConvertToFloat64_EmptyData(t *testing.T) {
	samples := convertToFloat64([]byte{}, 16, 1)
	if len(samples) != 0 {
		t.Errorf("expected 0 samples, got %d", len(samples))
	}
}
func TestParseWAVHeader_BasicMetadata(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_basic.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      60.0,
		sampleRate:    44100,
		channels:      2,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.SampleRate != 44100 {
		t.Errorf("SampleRate incorrect: got %d, want 44100", metadata.SampleRate)
	}
	if metadata.Channels != 2 {
		t.Errorf("Channels incorrect: got %d, want 2", metadata.Channels)
	}
	if metadata.BitsPerSample != 16 {
		t.Errorf("BitsPerSample incorrect: got %d, want 16", metadata.BitsPerSample)
	}
	if metadata.Duration < 59.9 || metadata.Duration > 60.1 {
		t.Errorf("Duration incorrect: got %f, want ~60.0", metadata.Duration)
	}
}
func TestParseWAVHeader_CommentMetadata(t *testing.T) {
	tmpDir := t.TempDir()
	expectedComment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549"
	path := createTestWAVFile(t, tmpDir, "test_comment.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      10.0,
		sampleRate:    48000,
		channels:      1,
		bitsPerSample: 16,
		comment:       expectedComment,
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Comment != expectedComment {
		t.Errorf("Comment incorrect: got %q, want %q", metadata.Comment, expectedComment)
	}
}
func TestParseWAVHeader_ArtistMetadata(t *testing.T) {
	tmpDir := t.TempDir()
	expectedArtist := "AudioMoth"
	path := createTestWAVFile(t, tmpDir, "test_artist.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      5.0,
		sampleRate:    48000,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        expectedArtist,
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Artist != expectedArtist {
		t.Errorf("Artist incorrect: got %q, want %q", metadata.Artist, expectedArtist)
	}
}
func TestParseWAVHeader_CommentAndArtist(t *testing.T) {
	tmpDir := t.TempDir()
	expectedComment := "Test recording comment"
	expectedArtist := "Test Artist"
	path := createTestWAVFile(t, tmpDir, "test_both.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      15.0,
		sampleRate:    44100,
		channels:      2,
		bitsPerSample: 16,
		comment:       expectedComment,
		artist:        expectedArtist,
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Comment != expectedComment {
		t.Errorf("Comment incorrect: got %q, want %q", metadata.Comment, expectedComment)
	}
	if metadata.Artist != expectedArtist {
		t.Errorf("Artist incorrect: got %q, want %q", metadata.Artist, expectedArtist)
	}
}
func TestParseWAVHeader_SampleRates(t *testing.T) {
	tmpDir := t.TempDir()
	testCases := []int{8000, 16000, 22050, 44100, 48000, 96000}
	for _, sr := range testCases {
		t.Run(fmt.Sprintf("%dHz", sr), func(t *testing.T) {
			path := createTestWAVFile(t, tmpDir, fmt.Sprintf("test_sr_%d.wav", sr), struct {
				duration      float64
				sampleRate    int
				channels      int
				bitsPerSample int
				comment       string
				artist        string
			}{
				duration:      1.0,
				sampleRate:    sr,
				channels:      1,
				bitsPerSample: 16,
				comment:       "",
				artist:        "",
			})
			metadata, err := ParseWAVHeader(path)
			if err != nil {
				t.Fatalf("Failed to parse WAV header: %v", err)
			}
			if metadata.SampleRate != sr {
				t.Errorf("SampleRate incorrect: got %d, want %d", metadata.SampleRate, sr)
			}
		})
	}
}
func TestParseWAVHeader_ChannelCounts(t *testing.T) {
	tmpDir := t.TempDir()
	testCases := []int{1, 2}
	for _, ch := range testCases {
		t.Run(fmt.Sprintf("%dch", ch), func(t *testing.T) {
			path := createTestWAVFile(t, tmpDir, fmt.Sprintf("test_ch_%d.wav", ch), struct {
				duration      float64
				sampleRate    int
				channels      int
				bitsPerSample int
				comment       string
				artist        string
			}{
				duration:      1.0,
				sampleRate:    44100,
				channels:      ch,
				bitsPerSample: 16,
				comment:       "",
				artist:        "",
			})
			metadata, err := ParseWAVHeader(path)
			if err != nil {
				t.Fatalf("Failed to parse WAV header: %v", err)
			}
			if metadata.Channels != ch {
				t.Errorf("Channels incorrect: got %d, want %d", metadata.Channels, ch)
			}
		})
	}
}
func TestParseWAVHeader_BitDepths(t *testing.T) {
	tmpDir := t.TempDir()
	testCases := []int{8, 16, 24, 32}
	for _, bits := range testCases {
		t.Run(fmt.Sprintf("%dbit", bits), func(t *testing.T) {
			path := createTestWAVFile(t, tmpDir, fmt.Sprintf("test_bits_%d.wav", bits), struct {
				duration      float64
				sampleRate    int
				channels      int
				bitsPerSample int
				comment       string
				artist        string
			}{
				duration:      1.0,
				sampleRate:    44100,
				channels:      1,
				bitsPerSample: bits,
				comment:       "",
				artist:        "",
			})
			metadata, err := ParseWAVHeader(path)
			if err != nil {
				t.Fatalf("Failed to parse WAV header: %v", err)
			}
			if metadata.BitsPerSample != bits {
				t.Errorf("BitsPerSample incorrect: got %d, want %d", metadata.BitsPerSample, bits)
			}
		})
	}
}
func TestParseWAVHeader_ShortDuration(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_short.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      0.1, // 100ms
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Duration < 0.09 || metadata.Duration > 0.11 {
		t.Errorf("Duration incorrect: got %f, want ~0.1", metadata.Duration)
	}
}
func TestParseWAVHeader_LongDuration(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_long.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      600.0, // 10 minutes
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Duration < 599.0 || metadata.Duration > 601.0 {
		t.Errorf("Duration incorrect: got %f, want ~600.0", metadata.Duration)
	}
}
func TestParseWAVHeader_NonExistentFile(t *testing.T) {
	_, err := ParseWAVHeader("/nonexistent/file.wav")
	if err == nil {
		t.Error("Expected error for non-existent file")
	}
}
func TestParseWAVHeader_NonWAVFile(t *testing.T) {
	tmpDir := t.TempDir()
	path := filepath.Join(tmpDir, "not_a_wav.txt")
	if err := os.WriteFile(path, []byte("This is not a WAV file"), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}
	_, err := ParseWAVHeader(path)
	if err == nil {
		t.Error("Expected error for non-WAV file")
	}
}
func TestParseWAVHeader_TruncatedFile(t *testing.T) {
	tmpDir := t.TempDir()
	path := filepath.Join(tmpDir, "truncated.wav")
	if err := os.WriteFile(path, []byte("RIFF"), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}
	_, err := ParseWAVHeader(path)
	if err == nil {
		t.Error("Expected error for truncated file")
	}
}
func TestParseWAVHeader_EmptyMetadataStrings(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_empty.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      10.0,
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Comment != "" {
		t.Errorf("Comment should be empty, got %q", metadata.Comment)
	}
	if metadata.Artist != "" {
		t.Errorf("Artist should be empty, got %q", metadata.Artist)
	}
}
func TestParseWAVHeader_LongCommentString(t *testing.T) {
	tmpDir := t.TempDir()
	longComment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C. This is a very long comment with additional information about the recording session."
	path := createTestWAVFile(t, tmpDir, "test_long_comment.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      10.0,
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       longComment,
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Comment != longComment {
		t.Errorf("Comment incorrect: got %q, want %q", metadata.Comment, longComment)
	}
}
func TestParseWAVHeader_FileModTime(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_modtime.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      5.0,
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	info, err := os.Stat(path)
	if err != nil {
		t.Fatalf("Failed to stat file: %v", err)
	}
	expectedModTime := info.ModTime()
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	// Allow 1 second tolerance for filesystem granularity
	diff := metadata.FileModTime.Sub(expectedModTime)
	if diff < -1*time.Second || diff > 1*time.Second {
		t.Errorf("FileModTime incorrect: got %v, want %v (diff: %v)",
			metadata.FileModTime, expectedModTime, diff)
	}
	if metadata.FileModTime.IsZero() {
		t.Error("FileModTime should not be zero")
	}
}
func TestExtractNullTerminatedString(t *testing.T) {
	testCases := []struct {
		name     string
		input    []byte
		expected string
	}{
		{
			name:     "string with null terminator",
			input:    []byte{'h', 'e', 'l', 'l', 'o', 0, 'w', 'o', 'r', 'l', 'd'},
			expected: "hello",
		},
		{
			name:     "string without null terminator",
			input:    []byte{'h', 'e', 'l', 'l', 'o'},
			expected: "hello",
		},
		{
			name:     "empty string",
			input:    []byte{},
			expected: "",
		},
		{
			name:     "only null terminator",
			input:    []byte{0},
			expected: "",
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			result := extractNullTerminatedString(tc.input)
			if result != tc.expected {
				t.Errorf("Result incorrect: got %q, want %q", result, tc.expected)
			}
		})
	}
}
// assertWAVHeader creates a WAV file and verifies ParseWAVHeaderMinimal returns expected values.
func assertWAVHeader(t *testing.T, tmpDir, filename string, wantSR int, wantDur float64, opts struct {
	duration      float64
	sampleRate    int
	channels      int
	bitsPerSample int
	comment       string
	artist        string
}) {
	t.Helper()
	path := createTestWAVFile(t, tmpDir, filename, opts)
	sr, dur, err := ParseWAVHeaderMinimal(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if sr != wantSR {
		t.Errorf("SampleRate: got %d, want %d", sr, wantSR)
	}
	if dur < wantDur-0.1 || dur > wantDur+0.1 {
		t.Errorf("Duration: got %f, want ~%f", dur, wantDur)
	}
}
func TestParseWAVHeaderMinimal(t *testing.T) {
	tmpDir := t.TempDir()
	t.Run("basic", func(t *testing.T) {
		assertWAVHeader(t, tmpDir, "test_minimal.wav", 44100, 10.0, struct {
			duration      float64
			sampleRate    int
			channels      int
			bitsPerSample int
			comment       string
			artist        string
		}{10.0, 44100, 1, 16, "", ""})
	})
	t.Run("sample_rates", func(t *testing.T) {
		for _, sr := range []int{8000, 22050, 44100, 48000, 96000} {
			t.Run(fmt.Sprintf("%dHz", sr), func(t *testing.T) {
				assertWAVHeader(t, tmpDir, fmt.Sprintf("test_sr_%d.wav", sr), sr, 5.0, struct {
					duration      float64
					sampleRate    int
					channels      int
					bitsPerSample int
					comment       string
					artist        string
				}{5.0, sr, 1, 16, "", ""})
			})
		}
	})
	t.Run("stereo", func(t *testing.T) {
		assertWAVHeader(t, tmpDir, "test_stereo.wav", 44100, 3.0, struct {
			duration      float64
			sampleRate    int
			channels      int
			bitsPerSample int
			comment       string
			artist        string
		}{3.0, 44100, 2, 16, "", ""})
	})
	t.Run("nonexistent", func(t *testing.T) {
		_, _, err := ParseWAVHeaderMinimal("/nonexistent/file.wav")
		if err == nil {
			t.Error("Expected error for non-existent file")
		}
	})
	t.Run("non_wav", func(t *testing.T) {
		path := filepath.Join(tmpDir, "notawav.wav")
		if err := os.WriteFile(path, []byte("Not a WAV file"), 0644); err != nil {
			t.Fatalf("Failed to create test file: %v", err)
		}
		_, _, err := ParseWAVHeaderMinimal(path)
		if err == nil {
			t.Error("Expected error for non-WAV file")
		}
	})
}

File addition: wav_metadata.go (----------)

[0.1]

package wav
import (
	"bytes"
	"encoding/binary"
	"fmt"
	"io"
	"os"
	"sync"
	"time"
	"github.com/cespare/xxhash/v2"
)
// Buffer pools for reducing GC pressure during batch imports
var (
	// headerBufferPool stores 200KB buffers for WAV header reading (full metadata)
	headerBufferPool = sync.Pool{
		New: func() any {
			buf := make([]byte, 200*1024)
			return &buf
		},
	}
	// minimalHeaderBufferPool stores 4KB buffers for minimal WAV header reading
	// 4KB is sufficient for fmt + data chunk headers in 99% of WAV files
	minimalHeaderBufferPool = sync.Pool{
		New: func() any {
			buf := make([]byte, 4*1024)
			return &buf
		},
	}
	// hashBufferPool stores 128KB buffers for hashing WAV files
	hashBufferPool = sync.Pool{
		New: func() any {
			buf := make([]byte, 128*1024)
			return &buf
		},
	}
)
// getHeaderBuffer gets a 200KB buffer from the pool
func getHeaderBuffer() *[]byte {
	return headerBufferPool.Get().(*[]byte)
}
// putHeaderBuffer returns a 200KB buffer to the pool
func putHeaderBuffer(buf *[]byte) {
	headerBufferPool.Put(buf)
}
// getMinimalHeaderBuffer gets a 4KB buffer from the pool
func getMinimalHeaderBuffer() *[]byte {
	return minimalHeaderBufferPool.Get().(*[]byte)
}
// putMinimalHeaderBuffer returns a 4KB buffer to the pool
func putMinimalHeaderBuffer(buf *[]byte) {
	minimalHeaderBufferPool.Put(buf)
}
// getHashBuffer gets a 128KB buffer from the pool
func getHashBuffer() *[]byte {
	return hashBufferPool.Get().(*[]byte)
}
// putHashBuffer returns a 128KB buffer to the pool
func putHashBuffer(buf *[]byte) {
	hashBufferPool.Put(buf)
}
// WAVMetadata contains metadata extracted from WAV file headers
type WAVMetadata struct {
	Duration      float64   // Duration in seconds
	SampleRate    int       // Sample rate in Hz
	Comment       string    // Comment from INFO chunk (may contain AudioMoth data)
	Artist        string    // Artist from INFO chunk
	Channels      int       // Number of audio channels
	BitsPerSample int       // Bits per sample
	FileModTime   time.Time // File modification time (fallback timestamp)
	FileSize      int64     // File size in bytes
}
// readAndParseHeader opens a WAV file, reads its header using the provided buffer pool,
// parses metadata, and sets file modification time and size.
func readAndParseHeader(filepath string, getBuf func() *[]byte, putBuf func(*[]byte)) (*WAVMetadata, error) {
	file, err := os.Open(filepath)
	if err != nil {
		return nil, fmt.Errorf("failed to open file: %w", err)
	}
	defer func() { _ = file.Close() }()
	fileInfo, err := file.Stat()
	if err != nil {
		return nil, fmt.Errorf("failed to get file info: %w", err)
	}
	bufPtr := getBuf()
	defer putBuf(bufPtr)
	buf := (*bufPtr)[:cap(*bufPtr)]
	n, err := file.Read(buf)
	if err != nil && err != io.EOF {
		return nil, fmt.Errorf("failed to read header: %w", err)
	}
	buf = buf[:n]
	metadata, err := parseWAVFromBytes(buf)
	if err != nil {
		return nil, err
	}
	metadata.FileModTime = fileInfo.ModTime()
	metadata.FileSize = fileInfo.Size()
	return metadata, nil
}
// ParseWAVHeader efficiently reads only the WAV file header to extract metadata.
// It reads the first 200KB of the file, which should be sufficient for all header chunks.
func ParseWAVHeader(filepath string) (*WAVMetadata, error) {
	return readAndParseHeader(filepath, getHeaderBuffer, putHeaderBuffer)
}
// ParseWAVHeaderMinimal reads only the first 4KB of a WAV file to extract essential metadata.
// This is optimized for batch processing where INFO chunks (comment/artist) are not needed.
// It's ~50x faster than ParseWAVHeader for large files due to reduced I/O.
// Returns (sampleRate, duration, error) - the minimal data needed for .data file generation.
func ParseWAVHeaderMinimal(filepath string) (sampleRate int, duration float64, err error) {
	metadata, err := readAndParseHeader(filepath, getMinimalHeaderBuffer, putMinimalHeaderBuffer)
	if err != nil {
		return 0, 0, err
	}
	return metadata.SampleRate, metadata.Duration, nil
}
// ParseWAVHeaderWithHash reads the WAV file once to extract both metadata and hash.
// This is more efficient than calling ParseWAVHeader and ComputeXXH64 separately,
// as it only opens the file once and reads it in a single pass.
// Returns (metadata, hash, error).
func ParseWAVHeaderWithHash(filepath string) (*WAVMetadata, string, error) {
	file, err := os.Open(filepath)
	if err != nil {
		return nil, "", fmt.Errorf("failed to open file: %w", err)
	}
	defer func() { _ = file.Close() }()
	fileInfo, err := file.Stat()
	if err != nil {
		return nil, "", fmt.Errorf("failed to get file info: %w", err)
	}
	headerBufPtr := getHeaderBuffer()
	defer putHeaderBuffer(headerBufPtr)
	headerBuf := (*headerBufPtr)[:cap(*headerBufPtr)]
	n, err := file.Read(headerBuf)
	if err != nil && err != io.EOF {
		return nil, "", fmt.Errorf("failed to read header: %w", err)
	}
	headerBuf = headerBuf[:n]
	metadata, err := parseWAVFromBytes(headerBuf)
	if err != nil {
		return nil, "", err
	}
	metadata.FileModTime = fileInfo.ModTime()
	metadata.FileSize = fileInfo.Size()
	// Hash: seek back to start and stream entire file
	if _, err := file.Seek(0, 0); err != nil {
		return nil, "", fmt.Errorf("failed to seek: %w", err)
	}
	hashBufPtr := getHashBuffer()
	defer putHashBuffer(hashBufPtr)
	hashBuf := *hashBufPtr
	h := xxhash.New()
	if _, err := io.CopyBuffer(h, file, hashBuf); err != nil {
		return nil, "", fmt.Errorf("failed to read file for hash: %w", err)
	}
	hash := fmt.Sprintf("%016x", h.Sum64())
	return metadata, hash, nil
}
// parseWAVFromBytes parses WAV metadata from a byte buffer
func parseWAVFromBytes(data []byte) (*WAVMetadata, error) {
	if len(data) < 44 {
		return nil, fmt.Errorf("file too small to be valid WAV")
	}
	if string(data[0:4]) != "RIFF" {
		return nil, fmt.Errorf("not a valid WAV file (missing RIFF header)")
	}
	if string(data[8:12]) != "WAVE" {
		return nil, fmt.Errorf("not a valid WAV file (missing WAVE format)")
	}
	metadata := &WAVMetadata{}
	offset := 12
	for offset < len(data)-8 {
		chunkID := string(data[offset : offset+4])
		chunkSize := int(binary.LittleEndian.Uint32(data[offset+4 : offset+8]))
		offset += 8
		switch chunkID {
		case "fmt ":
			parseFmtChunkData(data[offset:], chunkSize, metadata)
		case "data":
			calcDataChunkDuration(chunkSize, metadata)
		case "LIST":
			parseLISTChunkData(data[offset:], chunkSize, metadata)
		}
		offset += chunkSize
		if chunkSize%2 != 0 {
			offset++
		}
	}
	if metadata.SampleRate == 0 {
		return nil, fmt.Errorf("invalid WAV file: missing or corrupt fmt chunk")
	}
	if metadata.Duration == 0 {
		return nil, fmt.Errorf("invalid WAV file: missing or corrupt data chunk")
	}
	return metadata, nil
}
// parseFmtChunkData extracts format info from a fmt chunk.
func parseFmtChunkData(data []byte, chunkSize int, m *WAVMetadata) {
	if chunkSize >= 16 && len(data) >= 16 {
		m.Channels = int(binary.LittleEndian.Uint16(data[2:4]))
		m.SampleRate = int(binary.LittleEndian.Uint32(data[4:8]))
		m.BitsPerSample = int(binary.LittleEndian.Uint16(data[14:16]))
	}
}
// calcDataChunkDuration computes duration from the data chunk size.
func calcDataChunkDuration(chunkSize int, m *WAVMetadata) {
	if m.SampleRate > 0 && m.Channels > 0 && m.BitsPerSample > 0 {
		bytesPerSample := m.BitsPerSample / 8
		bytesPerSecond := m.SampleRate * m.Channels * bytesPerSample
		if bytesPerSecond > 0 {
			m.Duration = float64(chunkSize) / float64(bytesPerSecond)
		}
	}
}
// parseLISTChunkData parses a LIST chunk for INFO metadata.
func parseLISTChunkData(data []byte, chunkSize int, m *WAVMetadata) {
	if chunkSize >= 4 && len(data) >= chunkSize {
		if string(data[:4]) == "INFO" {
			parseINFOChunk(data[4:chunkSize], m)
		}
	}
}
// parseINFOChunk parses INFO list chunk for comment and artist metadata
func parseINFOChunk(data []byte, metadata *WAVMetadata) {
	offset := 0
	for offset < len(data)-8 {
		if offset+8 > len(data) {
			break
		}
		subchunkID := string(data[offset : offset+4])
		subchunkSize := int(binary.LittleEndian.Uint32(data[offset+4 : offset+8]))
		offset += 8
		if offset+subchunkSize > len(data) {
			break
		}
		value := extractNullTerminatedString(data[offset : offset+subchunkSize])
		switch subchunkID {
		case "ICMT":
			metadata.Comment = value
		case "IART":
			metadata.Artist = value
		}
		offset += subchunkSize
		if subchunkSize%2 != 0 {
			offset++
		}
	}
}
// extractNullTerminatedString extracts a null-terminated string from bytes
func extractNullTerminatedString(data []byte) string {
	before, _, ok := bytes.Cut(data, []byte{0})
	if ok {
		return string(before)
	}
	return string(data)
}
// wavChunkInfo holds parsed WAV format and data chunk locations.
type wavChunkInfo struct {
	sampleRate    int
	channels      int
	bitsPerSample int
	dataOffset    int64
	dataSize      int64
}
// parseWAVChunks reads WAV chunks from the current file position, returning
// format info and data chunk location. Returns error if no data chunk is found.
func parseWAVChunks(file *os.File) (wavChunkInfo, error) {
	var info wavChunkInfo
	for {
		chunkHeader := make([]byte, 8)
		if _, err := io.ReadFull(file, chunkHeader); err != nil {
			if err == io.EOF {
				break
			}
			return info, fmt.Errorf("failed to read chunk header: %w", err)
		}
		chunkID := string(chunkHeader[0:4])
		chunkSize := int64(binary.LittleEndian.Uint32(chunkHeader[4:8]))
		switch chunkID {
		case "fmt ":
			fmtData := make([]byte, chunkSize)
			if _, err := io.ReadFull(file, fmtData); err != nil {
				return info, fmt.Errorf("failed to read fmt chunk: %w", err)
			}
			if len(fmtData) >= 16 {
				info.channels = int(binary.LittleEndian.Uint16(fmtData[2:4]))
				info.sampleRate = int(binary.LittleEndian.Uint32(fmtData[4:8]))
				info.bitsPerSample = int(binary.LittleEndian.Uint16(fmtData[14:16]))
			}
		case "data":
			info.dataOffset, _ = file.Seek(0, io.SeekCurrent)
			info.dataSize = chunkSize
			return info, nil
		default:
			if _, err := file.Seek(chunkSize, io.SeekCurrent); err != nil {
				return info, fmt.Errorf("failed to skip chunk: %w", err)
			}
		}
		if chunkSize%2 != 0 {
			if _, err := file.Seek(1, io.SeekCurrent); err != nil {
				return info, fmt.Errorf("failed to skip padding: %w", err)
			}
		}
	}
	return info, fmt.Errorf("no data chunk found in WAV file")
}
// calcWAVReadRange computes the byte offset and size to read from the data chunk.
func calcWAVReadRange(startSec, endSec float64, info wavChunkInfo) (startOffset, readSize int64) {
	bytesPerSample := info.bitsPerSample / 8
	blockAlign := bytesPerSample * info.channels
	if startSec > 0 {
		startSample := int64(startSec * float64(info.sampleRate))
		startOffset = min(startSample*int64(blockAlign), info.dataSize)
	}
	if endSec > 0 {
		endSample := int64(endSec * float64(info.sampleRate))
		endOffset := min(endSample*int64(blockAlign), info.dataSize)
		if endOffset > startOffset {
			readSize = endOffset - startOffset
		}
	} else {
		readSize = info.dataSize - startOffset
	}
	return
}
// parseWAVInfo opens a WAV file, validates its header, and parses chunks.
// Returns the parsed chunk info and the open file (caller must close).
func parseWAVInfo(filepath string) (f *os.File, info wavChunkInfo, err error) {
	f, err = os.Open(filepath)
	if err != nil {
		return nil, wavChunkInfo{}, fmt.Errorf("failed to open file: %w", err)
	}
	defer func() {
		if err != nil {
			_ = f.Close()
		}
	}()
	headerBuf := make([]byte, 44)
	if _, err = io.ReadFull(f, headerBuf); err != nil {
		return nil, wavChunkInfo{}, fmt.Errorf("failed to read header: %w", err)
	}
	if string(headerBuf[0:4]) != "RIFF" || string(headerBuf[8:12]) != "WAVE" {
		return nil, wavChunkInfo{}, fmt.Errorf("not a valid WAV file")
	}
	if _, err = f.Seek(12, 0); err != nil {
		return nil, wavChunkInfo{}, fmt.Errorf("failed to seek: %w", err)
	}
	info, err = parseWAVChunks(f)
	if err != nil {
		return nil, wavChunkInfo{}, err
	}
	if info.sampleRate == 0 || info.channels == 0 || info.bitsPerSample == 0 {
		return nil, wavChunkInfo{}, fmt.Errorf("missing or invalid fmt chunk")
	}
	return f, info, nil
}
// readAudioSegment reads audio bytes from an already-parsed WAV file.
func readAudioSegment(file *os.File, info wavChunkInfo, startOffset, readSize int64) ([]byte, error) {
	if readSize == 0 {
		return nil, nil
	}
	if _, err := file.Seek(info.dataOffset+startOffset, io.SeekStart); err != nil {
		return nil, fmt.Errorf("failed to seek to data segment: %w", err)
	}
	audioData := make([]byte, readSize)
	if _, err := io.ReadFull(file, audioData); err != nil {
		if err != io.EOF && err != io.ErrUnexpectedEOF {
			return nil, fmt.Errorf("failed to read audio data: %w", err)
		}
	}
	return audioData, nil
}
// ReadWAVSegmentSamples reads a specific time range of audio samples from a WAV file.
// If startSec < 0, it starts from 0.
// If endSec <= 0 or endSec > duration, it reads to the end.
func ReadWAVSegmentSamples(filepath string, startSec, endSec float64) ([]float64, int, error) {
	file, info, err := parseWAVInfo(filepath)
	if err != nil {
		return nil, 0, err
	}
	defer func() { _ = file.Close() }()
	startOffset, readSize := calcWAVReadRange(startSec, endSec, info)
	audioData, err := readAudioSegment(file, info, startOffset, readSize)
	if err != nil {
		return nil, 0, err
	}
	if readSize == 0 {
		return []float64{}, info.sampleRate, nil
	}
	samples := convertToFloat64(audioData, info.bitsPerSample, info.channels)
	return samples, info.sampleRate, nil
}
// ReadWAVSamples reads audio samples from a WAV file and returns them as float64.
// Mono files: returns single channel.
// Stereo files: returns left channel only.
// Samples are normalized to the range -1.0 to 1.0.
func ReadWAVSamples(filepath string) ([]float64, int, error) {
	return ReadWAVSegmentSamples(filepath, 0, 0)
}
// convertToFloat64 converts raw audio bytes to float64 samples
// Returns mono (left channel only for stereo)
func convertToFloat64(data []byte, bitsPerSample, channels int) []float64 {
	bytesPerSample := bitsPerSample / 8
	blockAlign := bytesPerSample * channels
	numSamples := len(data) / blockAlign
	samples := make([]float64, numSamples)
	switch bitsPerSample {
	case 16:
		for i := range numSamples {
			offset := i * blockAlign
			sample := int16(binary.LittleEndian.Uint16(data[offset : offset+2]))
			samples[i] = float64(sample) / 32768.0
		}
	case 24:
		for i := range numSamples {
			offset := i * blockAlign
			b := data[offset : offset+3]
			sample := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16
			if sample >= 0x800000 {
				sample -= 0x1000000
			}
			samples[i] = float64(sample) / 8388608.0
		}
	case 32:
		for i := range numSamples {
			offset := i * blockAlign
			sample := int32(binary.LittleEndian.Uint32(data[offset : offset+4]))
			samples[i] = float64(sample) / 2147483648.0
		}
	default:
		for i := range numSamples {
			offset := i * blockAlign
			sample := int16(binary.LittleEndian.Uint16(data[offset : offset+2]))
			samples[i] = float64(sample) / 32768.0
		}
	}
	return samples
}

File addition: audiomoth_parser_test.go (----------)

[0.1]

package wav
import (
	"strings"
	"testing"
	"time"
)
func TestIsAudioMoth(t *testing.T) {
	t.Run("should identify AudioMoth files by artist field", func(t *testing.T) {
		if !IsAudioMoth("", "AudioMoth") {
			t.Error("Should identify AudioMoth by artist field")
		}
		if !IsAudioMoth("", "AudioMoth 123456") {
			t.Error("Should identify AudioMoth with ID in artist field")
		}
		if IsAudioMoth("", "Other Artist") {
			t.Error("Should not identify non-AudioMoth artist")
		}
	})
	t.Run("should identify AudioMoth files by comment field", func(t *testing.T) {
		if !IsAudioMoth("Recorded by AudioMoth...", "") {
			t.Error("Should identify AudioMoth by comment field")
		}
		if IsAudioMoth("Regular recording comment", "") {
			t.Error("Should not identify non-AudioMoth comment")
		}
	})
	t.Run("should handle missing metadata", func(t *testing.T) {
		if IsAudioMoth("", "") {
			t.Error("Should not identify empty strings as AudioMoth")
		}
	})
	t.Run("should be case insensitive", func(t *testing.T) {
		if !IsAudioMoth("", "audiomoth") {
			t.Error("Should be case insensitive")
		}
		if !IsAudioMoth("", "AUDIOMOTH") {
			t.Error("Should be case insensitive")
		}
	})
}
func TestParseAudioMothComment(t *testing.T) {
	t.Run("should parse a valid structured AudioMoth comment", testParseStructuredComment)
	t.Run("should return error for invalid comments", testParseInvalidComments)
	t.Run("should handle different timezone formats", testParseTimezoneFormats)
	t.Run("should parse all gain levels", testParseAllGainLevels)
	t.Run("should handle negative temperatures", testParseNegativeTemp)
	t.Run("should fallback to legacy parsing", testParseLegacyFallback)
}
func testParseStructuredComment(t *testing.T) {
	comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C."
	result, err := ParseAudioMothComment(comment)
	if err != nil {
		t.Fatalf("Failed to parse comment: %v", err)
	}
	expected := time.Date(2025, 2, 24, 21, 0, 0, 0, time.FixedZone("UTC+13", 13*3600))
	if !result.Timestamp.Equal(expected) {
		t.Errorf("Timestamp incorrect: got %v, want %v", result.Timestamp, expected)
	}
	utc := result.Timestamp.UTC()
	expectedUTC := time.Date(2025, 2, 24, 8, 0, 0, 0, time.UTC)
	if !utc.Equal(expectedUTC) {
		t.Errorf("UTC timestamp incorrect: got %v, want %v", utc, expectedUTC)
	}
	if result.RecorderID != "248AB50153AB0549" {
		t.Errorf("RecorderID incorrect: got %s, want 248AB50153AB0549", result.RecorderID)
	}
	if result.Gain != GainMedium {
		t.Errorf("Gain incorrect: got %s, want %s", result.Gain, GainMedium)
	}
	if result.BatteryV != 4.3 {
		t.Errorf("BatteryV incorrect: got %f, want 4.3", result.BatteryV)
	}
	if result.TempC != 15.8 {
		t.Errorf("TempC incorrect: got %f, want 15.8", result.TempC)
	}
}
func testParseInvalidComments(t *testing.T) {
	invalidComments := []string{
		"Not an AudioMoth comment",
		"Recorded at invalid time format",
		"Short comment",
		"",
		"AudioMoth without proper format",
	}
	for _, comment := range invalidComments {
		_, err := ParseAudioMothComment(comment)
		if err == nil {
			t.Errorf("Expected error for invalid comment: %s", comment)
		}
	}
}
func testParseTimezoneFormats(t *testing.T) {
	commentUTCMinus := "Recorded at 10:30:45 15/06/2024 (UTC-5) by AudioMoth 123456789ABCDEF0 at high gain while battery was 3.9V and temperature was 22.1C."
	result, err := ParseAudioMothComment(commentUTCMinus)
	if err != nil {
		t.Fatalf("Failed to parse comment: %v", err)
	}
	expected := time.Date(2024, 6, 15, 10, 30, 45, 0, time.FixedZone("UTC-5", -5*3600))
	if !result.Timestamp.Equal(expected) {
		t.Errorf("Timestamp incorrect: got %v, want %v", result.Timestamp, expected)
	}
	if result.Gain != GainHigh {
		t.Errorf("Gain incorrect: got %s, want %s", result.Gain, GainHigh)
	}
	if result.BatteryV != 3.9 {
		t.Errorf("BatteryV incorrect: got %f, want 3.9", result.BatteryV)
	}
	if result.TempC != 22.1 {
		t.Errorf("TempC incorrect: got %f, want 22.1", result.TempC)
	}
}
func testParseAllGainLevels(t *testing.T) {
	testCases := []struct {
		gainStr  string
		expected GainLevel
	}{
		{"low", GainLow},
		{"low-medium", GainLowMedium},
		{"medium", GainMedium},
		{"medium-high", GainMediumHigh},
		{"high", GainHigh},
	}
	for _, tc := range testCases {
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at " + tc.gainStr + " gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		if err != nil {
			t.Errorf("Failed to parse comment with gain %s: %v", tc.gainStr, err)
			continue
		}
		if result.Gain != tc.expected {
			t.Errorf("Gain incorrect for %s: got %s, want %s", tc.gainStr, result.Gain, tc.expected)
		}
	}
}
func testParseNegativeTemp(t *testing.T) {
	comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was -5.2C."
	result, err := ParseAudioMothComment(comment)
	if err != nil {
		t.Fatalf("Failed to parse comment: %v", err)
	}
	if result.TempC != -5.2 {
		t.Errorf("TempC incorrect: got %f, want -5.2", result.TempC)
	}
}
func testParseLegacyFallback(t *testing.T) {
	comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C"
	result, err := ParseAudioMothComment(comment)
	if err == nil {
		if result.RecorderID == "" {
			t.Error("RecorderID should not be empty")
		}
	}
}
func TestParseGainLevel(t *testing.T) {
	testCases := []struct {
		input    string
		expected GainLevel
		wantErr  bool
	}{
		{"low", GainLow, false},
		{"LOW", GainLow, false},
		{"  low  ", GainLow, false},
		{"low-medium", GainLowMedium, false},
		{"medium", GainMedium, false},
		{"medium-high", GainMediumHigh, false},
		{"high", GainHigh, false},
		{"invalid", "", true},
		{"", "", true},
		{"ultra", "", true},
	}
	for _, tc := range testCases {
		t.Run(tc.input, func(t *testing.T) {
			result, err := parseGainLevel(tc.input)
			if tc.wantErr {
				if err == nil {
					t.Errorf("Expected error for input %q, got nil", tc.input)
				}
			} else {
				if err != nil {
					t.Errorf("Unexpected error for input %q: %v", tc.input, err)
				}
				if result != tc.expected {
					t.Errorf("Result incorrect for %q: got %s, want %s", tc.input, result, tc.expected)
				}
			}
		})
	}
}
func TestParseAudioMothTimestamp(t *testing.T) {
	t.Run("should parse standard timestamp format", func(t *testing.T) {
		result, err := parseAudioMothTimestamp("21:00:00", "24/02/2025", "UTC+13")
		if err != nil {
			t.Fatalf("Failed to parse timestamp: %v", err)
		}
		expected := time.Date(2025, 2, 24, 21, 0, 0, 0, time.FixedZone("UTC+13", 13*3600))
		if !result.Equal(expected) {
			t.Errorf("Timestamp incorrect: got %v, want %v", result, expected)
		}
	})
	t.Run("should parse timestamp with +HH format", func(t *testing.T) {
		result, err := parseAudioMothTimestamp("10:30:45", "15/06/2024", "+13")
		if err != nil {
			t.Fatalf("Failed to parse timestamp: %v", err)
		}
		expected := time.Date(2024, 6, 15, 10, 30, 45, 0, time.FixedZone("UTC+13", 13*3600))
		if !result.Equal(expected) {
			t.Errorf("Timestamp incorrect: got %v, want %v", result, expected)
		}
	})
	t.Run("should parse negative timezone offset", func(t *testing.T) {
		result, err := parseAudioMothTimestamp("10:30:45", "15/06/2024", "UTC-5")
		if err != nil {
			t.Fatalf("Failed to parse timestamp: %v", err)
		}
		expected := time.Date(2024, 6, 15, 10, 30, 45, 0, time.FixedZone("UTC-5", -5*3600))
		if !result.Equal(expected) {
			t.Errorf("Timestamp incorrect: got %v, want %v", result, expected)
		}
	})
	t.Run("should handle invalid time format", func(t *testing.T) {
		_, err := parseAudioMothTimestamp("25:00:00", "15/06/2024", "UTC+13")
		// Note: Go's time.Date will normalize invalid times, so this might not error
		// The error would be caught if the format doesn't match
		_ = err
	})
	t.Run("should handle invalid date format", func(t *testing.T) {
		_, err := parseAudioMothTimestamp("10:30:45", "32/13/2024", "UTC+13")
		// Note: Go's time.Date will normalize invalid dates
		_ = err
	})
}
func TestStructuredVsLegacyParsing(t *testing.T) {
	t.Run("should prefer structured parsing", func(t *testing.T) {
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		if err != nil {
			t.Fatalf("Failed to parse comment: %v", err)
		}
		// Verify it parsed correctly
		if result.RecorderID != "248AB50153AB0549" {
			t.Errorf("RecorderID incorrect: got %s, want 248AB50153AB0549", result.RecorderID)
		}
	})
	t.Run("should handle legacy format", func(t *testing.T) {
		// Create a comment that matches legacy space-separated format
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C."
		// The structured parser should handle this
		result, err := ParseAudioMothComment(comment)
		if err != nil {
			// If structured fails, legacy should catch it
			// (though for this format, structured should work)
			t.Logf("Note: Structured parsing failed, expected legacy to handle: %v", err)
		} else {
			if result.RecorderID == "" {
				t.Error("RecorderID should not be empty")
			}
		}
	})
}
func TestAudioMothCommentEdgeCases(t *testing.T) {
	t.Run("should handle extra whitespace", func(t *testing.T) {
		comment := "Recorded at  21:00:00  24/02/2025  (UTC+13)  by  AudioMoth  248AB50153AB0549  at  medium  gain  while  battery  was  4.3V  and  temperature  was  15.8C."
		// Depending on implementation, this might or might not parse
		_, err := ParseAudioMothComment(comment)
		if err != nil {
			// Expected - structured regex is strict
			t.Logf("Extra whitespace causes parsing to fail (expected): %v", err)
		}
	})
	t.Run("should handle different case in gain", func(t *testing.T) {
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at MEDIUM gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		if err == nil {
			if result.Gain != GainMedium {
				t.Errorf("Gain should be normalized: got %s, want %s", result.Gain, GainMedium)
			}
		}
	})
	t.Run("should handle non-hex recorder ID via legacy parser", func(t *testing.T) {
		// Structured regex expects [A-F0-9]+ hex format and will not match
		// Legacy parser will catch this and parse it (more lenient)
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth GGGGGGGGGGGGGGGG at medium gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		// Legacy parser is lenient and accepts any recorder ID
		if err != nil {
			t.Fatalf("Legacy parser should handle non-hex recorder ID: %v", err)
		}
		// Verify it parsed the recorder ID (even though it's not valid hex)
		if result.RecorderID != "GGGGGGGGGGGGGGGG" {
			t.Errorf("RecorderID incorrect: got %s, want GGGGGGGGGGGGGGGG", result.RecorderID)
		}
	})
	t.Run("should handle recorder ID of different lengths", func(t *testing.T) {
		// Short ID
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth ABCD at medium gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		if err != nil {
			t.Fatalf("Failed to parse comment with short ID: %v", err)
		}
		if !strings.Contains(result.RecorderID, "ABCD") {
			t.Errorf("RecorderID should contain ABCD, got %s", result.RecorderID)
		}
	})
}

File addition: audiomoth_parser.go (----------)

[0.1]

package wav
import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
	"time"
)
// GainLevel represents the gain_level enum for AudioMoth recordings
type GainLevel string
// AudioMoth gain level enum constants
const (
	GainLow        GainLevel = "low"
	GainLowMedium  GainLevel = "low-medium"
	GainMedium     GainLevel = "medium"
	GainMediumHigh GainLevel = "medium-high"
	GainHigh       GainLevel = "high"
)
// AudioMothData contains parsed data from AudioMoth comment field
type AudioMothData struct {
	Timestamp  time.Time
	RecorderID string
	Gain       GainLevel
	BatteryV   float64
	TempC      float64
}
// AudioMoth comment example:
// "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C."
var (
	// Pattern to detect AudioMoth comments
	audiomothPattern = regexp.MustCompile(`(?i)AudioMoth`)
	// Pattern to extract structured data
	structuredPattern = regexp.MustCompile(
		`Recorded at (\d{2}:\d{2}:\d{2}) (\d{2}/\d{2}/\d{4}) \(UTC([+-]\d+)\) by AudioMoth ([A-F0-9]+) at ([\w-]+) gain while battery was ([\d.]+)V and temperature was ([-\d.]+)C`,
	)
)
// IsAudioMoth detects if a WAV file is from an AudioMoth recorder by checking comment and artist fields
func IsAudioMoth(comment, artist string) bool {
	return audiomothPattern.MatchString(comment) || audiomothPattern.MatchString(artist)
}
// ParseAudioMothComment extracts timestamp, gain, battery, and temperature from an AudioMoth comment.
func ParseAudioMothComment(comment string) (*AudioMothData, error) {
	// Try structured parsing first (newer format)
	if data, err := parseStructuredComment(comment); err == nil {
		return data, nil
	}
	// Fallback to legacy space-separated parsing
	return parseLegacyComment(comment)
}
// parseStructuredComment parses newer AudioMoth comment format using regex
func parseStructuredComment(comment string) (*AudioMothData, error) {
	matches := structuredPattern.FindStringSubmatch(comment)
	if matches == nil {
		return nil, fmt.Errorf("comment does not match structured AudioMoth format")
	}
	timeStr := matches[1]
	dateStr := matches[2]
	timezoneStr := matches[3]
	recorderID := matches[4]
	gainStr := matches[5]
	batteryStr := matches[6]
	tempStr := matches[7]
	timestamp, err := parseAudioMothTimestamp(timeStr, dateStr, timezoneStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse timestamp: %w", err)
	}
	gain, err := parseGainLevel(gainStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse gain: %w", err)
	}
	batteryV, err := strconv.ParseFloat(batteryStr, 64)
	if err != nil {
		return nil, fmt.Errorf("failed to parse battery voltage: %w", err)
	}
	tempC, err := strconv.ParseFloat(tempStr, 64)
	if err != nil {
		return nil, fmt.Errorf("failed to parse temperature: %w", err)
	}
	return &AudioMothData{
		Timestamp:  timestamp,
		RecorderID: recorderID,
		Gain:       gain,
		BatteryV:   batteryV,
		TempC:      tempC,
	}, nil
}
// parseLegacyComment parses older AudioMoth comment format (space-separated).
func parseLegacyComment(comment string) (*AudioMothData, error) {
	parts := strings.Fields(comment)
	if len(parts) < 10 {
		return nil, fmt.Errorf("comment has insufficient parts (got %d, need at least 10)", len(parts))
	}
	timeStr := parts[2]
	dateStr := parts[3]
	timezoneStr := strings.Trim(parts[4], "()")
	recorderID := parts[7]
	gainStr := parts[9]
	timestamp, err := parseAudioMothTimestamp(timeStr, dateStr, timezoneStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse timestamp: %w", err)
	}
	gain, err := parseGainLevel(gainStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse gain: %w", err)
	}
	batteryStr := parts[len(parts)-5]
	batteryStr = strings.TrimSuffix(batteryStr, "V")
	batteryV, err := strconv.ParseFloat(batteryStr, 64)
	if err != nil {
		return nil, fmt.Errorf("failed to parse battery voltage: %w", err)
	}
	tempStr := parts[len(parts)-1]
	tempStr = strings.TrimSuffix(tempStr, ".")
	tempStr = strings.TrimSuffix(tempStr, "C")
	tempC, err := strconv.ParseFloat(tempStr, 64)
	if err != nil {
		return nil, fmt.Errorf("failed to parse temperature: %w", err)
	}
	return &AudioMothData{
		Timestamp:  timestamp,
		RecorderID: recorderID,
		Gain:       gain,
		BatteryV:   batteryV,
		TempC:      tempC,
	}, nil
}
// parseAudioMothTimestamp parses AudioMoth timestamp from time, date, and timezone strings
func parseAudioMothTimestamp(timeStr, dateStr, timezoneStr string) (time.Time, error) {
	timeParts := strings.Split(timeStr, ":")
	if len(timeParts) != 3 {
		return time.Time{}, fmt.Errorf("invalid time format: %s", timeStr)
	}
	hour, _ := strconv.Atoi(timeParts[0])
	minute, _ := strconv.Atoi(timeParts[1])
	second, _ := strconv.Atoi(timeParts[2])
	dateParts := strings.Split(dateStr, "/")
	if len(dateParts) != 3 {
		return time.Time{}, fmt.Errorf("invalid date format: %s", dateStr)
	}
	day, _ := strconv.Atoi(dateParts[0])
	month, _ := strconv.Atoi(dateParts[1])
	year, _ := strconv.Atoi(dateParts[2])
	timezoneStr = strings.TrimPrefix(timezoneStr, "UTC")
	offsetHours, err := strconv.Atoi(timezoneStr)
	if err != nil {
		return time.Time{}, fmt.Errorf("invalid timezone offset: %s", timezoneStr)
	}
	offsetSeconds := offsetHours * 3600
	loc := time.FixedZone(fmt.Sprintf("UTC%+d", offsetHours), offsetSeconds)
	timestamp := time.Date(year, time.Month(month), day, hour, minute, second, 0, loc)
	return timestamp, nil
}
// parseGainLevel converts string gain level to GainLevel enum
func parseGainLevel(gainStr string) (GainLevel, error) {
	gainStr = strings.ToLower(strings.TrimSpace(gainStr))
	switch gainStr {
	case "low":
		return GainLow, nil
	case "low-medium":
		return GainLowMedium, nil
	case "medium":
		return GainMedium, nil
	case "medium-high":
		return GainMediumHigh, nil
	case "high":
		return GainHigh, nil
	default:
		return "", fmt.Errorf("unknown gain level: %s", gainStr)
	}
}

File deletion: wav_writer_test.go

BF:BFD[5.1] → [6.749:791]

BF:BFD[6.791] → [6.1:1]

B:BD[6.1] → [6.2:748]

package utils
import (
	"os"
	"path/filepath"
	"testing"
)
func TestWriteWAVFile(t *testing.T) {
	t.Run("writes valid samples", func(t *testing.T) {
		path := filepath.Join(t.TempDir(), "test.wav")
		samples := []float64{0.5, -0.5, 1.5, -1.5} // includes out of bounds for clamping
		err := WriteWAVFile(path, samples, 8000)
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		info, err := os.Stat(path)
		if err != nil || info.Size() == 0 {
			t.Error("expected file to be written with data")
		}
	})
	t.Run("fails on empty samples", func(t *testing.T) {
		path := filepath.Join(t.TempDir(), "empty.wav")
		err := WriteWAVFile(path, []float64{}, 8000)
		if err == nil {
			t.Error("expected error for empty samples")
		}
	})
}

File deletion: wav_writer.go

BF:BFD[5.1] → [5.6783:6820]

BF:BFD[5.6820] → [5.4507:4507]

B:BD[5.4507] → [5.4508:4573]

B:BD[5.4573] → [3.24789:24806]

∅:D[3.24806] → [5.4573:6306]

B:BD[5.4573] → [5.4573:6306]

∅:D[6.7103] → [5.6563:6782]

∅:D[3.24846] → [5.6563:6782]

B:BD[5.6563] → [5.6563:6782]

B:BD[5.6306] → [3.24807:24846]

package utils
import (
	"bufio"
	"encoding/binary"
	"fmt"
	"os"
	"skraak/audio"
)
// WriteWAVFile writes audio samples to a WAV file.
// Samples should be in the range -1.0 to 1.0.
// Output is mono 16-bit PCM.
func WriteWAVFile(filepath string, samples []float64, sampleRate int) error {
	if len(samples) == 0 {
		return fmt.Errorf("no samples to write")
	}
	file, err := os.Create(filepath)
	if err != nil {
		return fmt.Errorf("failed to create file: %w", err)
	}
	w := bufio.NewWriterSize(file, 64*1024)
	// Write WAV and flush; check close to ensure data is persisted.
	err = func() error {
		// WAV parameters
		channels := 1
		bitsPerSample := 16
		bytesPerSample := bitsPerSample / 8
		byteRate := sampleRate * channels * bytesPerSample
		blockAlign := channels * bytesPerSample
		dataSize := len(samples) * bytesPerSample
		totalSize := 36 + dataSize // 36 = header size before data chunk
		// 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))
		if _, err := w.Write(header); err != nil {
			return err
		}
		// Convert all float64 samples to 16-bit PCM in a single buffer
		if _, err := w.Write(buf); err != nil {
			return err
		}
		return w.Flush()
	}()
	if err2 := file.Close(); err2 != nil {
		if err == nil {
			err = fmt.Errorf("failed to close file: %w", err2)
		}
	}
	return err
}
		buf := audio.Float64ToPCM16(samples)

File deletion: wav_metadata_test.go

BF:BFD[5.1] → [5.25412:25456]

BF:BFD[5.25456] → [5.6822:6822]

B:BD[5.6822] → [5.6823:6882]

B:BD[5.6882] → [7.10374:10382]

∅:D[7.10382] → [5.6882:10037]

B:BD[5.6882] → [5.6882:10037]

B:BD[5.10037] → [7.10383:13667]

∅:D[7.13667] → [5.10037:10040]

B:BD[5.10037] → [5.10037:10040]

B:BD[5.10040] → [7.13668:15670]

B:BD[7.15670] → [8.21745:21827]

∅:D[8.21827] → [7.15751:16117]

B:BD[7.15751] → [7.15751:16117]

B:BD[7.16117] → [9.6:60]

∅:D[9.60] → [5.10126:10150]

B:BD[5.10126] → [5.10126:10150]

B:BD[5.10150] → [9.61:394]

∅:D[9.394] → [5.10561:10562]

B:BD[5.10561] → [5.10561:10562]

B:BD[5.10562] → [9.395:504]

∅:D[9.504] → [5.10675:10676]

B:BD[5.10675] → [5.10675:10676]

B:BD[5.10676] → [9.505:972]

∅:D[9.972] → [5.10897:10898]

B:BD[5.10897] → [5.10897:10898]

B:BD[5.10898] → [9.973:1052]

∅:D[9.1052] → [5.11018:11019]

B:BD[5.11018] → [5.11018:11019]

B:BD[5.11019] → [9.1053:1490]

∅:D[9.1490] → [5.11234:11239]

B:BD[5.11234] → [5.11234:11239]

B:BD[5.11239] → [9.1491:1600]

∅:D[9.1600] → [5.11759:11760]

B:BD[5.11759] → [5.11759:11760]

B:BD[5.11760] → [9.1601:1732]

∅:D[9.1732] → [5.11873:11874]

B:BD[5.11873] → [5.11873:11874]

B:BD[5.11874] → [9.1733:1811]

∅:D[9.1811] → [5.12010:12011]

B:BD[5.12010] → [5.12010:12011]

B:BD[5.12011] → [9.1812:2184]

∅:D[9.2184] → [5.12707:12712]

B:BD[5.12707] → [5.12707:12712]

B:BD[5.12712] → [9.2185:2294]

∅:D[9.2294] → [5.13234:13235]

B:BD[5.13234] → [5.13234:13235]

B:BD[5.13235] → [9.2295:2421]

∅:D[9.2421] → [5.13348:13349]

B:BD[5.13348] → [5.13348:13349]

B:BD[5.13349] → [9.2422:2502]

∅:D[9.2502] → [5.13481:13482]

B:BD[5.13481] → [5.13481:13482]

B:BD[5.13482] → [9.2503:2934]

∅:D[9.2934] → [5.13609:13614]

B:BD[5.13609] → [5.13609:13614]

B:BD[5.13614] → [9.2935:3044]

∅:D[9.3044] → [5.13806:13807]

B:BD[5.13806] → [5.13806:13807]

B:BD[5.13807] → [9.3045:3300]

∅:D[9.3300] → [5.14256:14257]

B:BD[5.14256] → [5.14256:14257]

B:BD[5.14257] → [9.3301:3376]

∅:D[9.3376] → [5.14378:14379]

B:BD[5.14378] → [5.14378:14379]

B:BD[5.14379] → [9.3377:3894]

∅:D[9.3894] → [5.14522:14528]

B:BD[5.14522] → [5.14522:14528]

B:BD[5.14536] → [5.14536:14537]

B:BD[5.14537] → [9.3895:4012]

∅:D[9.4012] → [5.14692:14693]

B:BD[5.14692] → [5.14692:14693]

B:BD[5.14693] → [9.4013:4141]

∅:D[9.4141] → [5.15144:15145]

B:BD[5.15144] → [5.15144:15145]

B:BD[5.15145] → [9.4142:4219]

∅:D[9.4219] → [5.15266:15267]

B:BD[5.15266] → [5.15266:15267]

B:BD[5.15267] → [9.4220:4706]

∅:D[9.4706] → [5.15400:15406]

B:BD[5.15400] → [5.15400:15406]

B:BD[5.15414] → [5.15414:15415]

B:BD[5.15415] → [9.4707:4824]

∅:D[9.4824] → [5.15572:15573]

B:BD[5.15572] → [5.15572:15573]

B:BD[5.15573] → [9.4825:4947]

∅:D[9.4947] → [5.16030:16031]

B:BD[5.16030] → [5.16030:16031]

B:BD[5.16031] → [9.4948:5021]

∅:D[9.5021] → [5.16152:16153]

B:BD[5.16152] → [5.16152:16153]

B:BD[5.16153] → [9.5022:5527]

∅:D[9.5527] → [5.16311:16317]

B:BD[5.16311] → [5.16311:16317]

B:BD[5.16325] → [5.16325:16326]

B:BD[5.16326] → [9.5528:5777]

∅:D[9.5777] → [5.16743:16748]

B:BD[5.16743] → [5.16743:16748]

∅:D[9.5783] → [5.16748:16749]

B:BD[5.16748] → [5.16748:16749]

B:BD[5.16749] → [9.5784:5861]

∅:D[9.5861] → [5.16862:16863]

B:BD[5.16862] → [5.16862:16863]

B:BD[5.16863] → [9.5862:6199]

∅:D[9.6199] → [5.16999:17004]

B:BD[5.16999] → [5.16999:17004]

B:BD[5.17004] → [9.6200:6309]

∅:D[9.6309] → [5.17426:17427]

B:BD[5.17426] → [5.17426:17427]

B:BD[5.17427] → [9.6310:6445]

∅:D[9.6445] → [5.17540:17541]

B:BD[5.17540] → [5.17540:17541]

B:BD[5.17541] → [9.6446:6522]

∅:D[9.6522] → [5.17685:17686]

B:BD[5.17685] → [5.17685:17686]

B:BD[5.17686] → [9.6523:6866]

∅:D[9.6866] → [5.17884:17889]

B:BD[5.17884] → [5.17884:17889]

B:BD[5.17889] → [9.6867:6976]

∅:D[9.6976] → [5.18173:18174]

B:BD[5.18173] → [5.18173:18174]

B:BD[5.18174] → [9.6977:7116]

∅:D[9.7116] → [5.18279:18280]

B:BD[5.18279] → [5.18279:18280]

B:BD[5.18280] → [9.7117:7296]

∅:D[9.7296] → [5.18573:18574]

B:BD[5.18573] → [5.18573:18574]

B:BD[5.18574] → [9.7297:7371]

∅:D[9.7371] → [5.18681:18682]

B:BD[5.18681] → [5.18681:18682]

B:BD[5.18682] → [9.7372:7903]

∅:D[9.7903] → [5.19098:19099]

B:BD[5.19098] → [5.19098:19099]

B:BD[5.19099] → [9.7904:8005]

∅:D[9.8005] → [5.19212:19213]

B:BD[5.19212] → [5.19212:19213]

B:BD[5.19213] → [9.8006:8090]

∅:D[9.8090] → [5.19312:19313]

B:BD[5.19312] → [5.19312:19313]

B:BD[5.19313] → [9.8091:8420]

∅:D[9.8420] → [5.19409:19414]

B:BD[5.19409] → [5.19409:19414]

B:BD[5.19414] → [9.8421:8530]

∅:D[9.8530] → [5.19720:19721]

B:BD[5.19720] → [5.19720:19721]

B:BD[5.19721] → [9.8531:8804]

∅:D[9.8804] → [5.20085:20086]

B:BD[5.20085] → [5.20085:20086]

B:BD[5.20086] → [9.8805:9044]

∅:D[9.9044] → [5.20199:20200]

B:BD[5.20199] → [5.20199:20200]

B:BD[5.20200] → [9.9045:9390]

∅:D[9.9390] → [5.20324:20329]

B:BD[5.20324] → [5.20324:20329]

B:BD[5.20329] → [9.9391:9700]

∅:D[9.9700] → [5.20747:20748]

B:BD[5.20747] → [5.20747:20748]

B:BD[5.20748] → [9.9701:10035]

∅:D[9.10035] → [5.20906:20907]

B:BD[5.20906] → [5.20906:20907]

B:BD[5.20907] → [9.10036:10162]

∅:D[9.10162] → [5.21020:21021]

B:BD[5.21020] → [5.21020:21021]

B:BD[5.21021] → [9.10163:10272]

∅:D[9.10272] → [5.21301:21302]

B:BD[5.21301] → [5.21301:21302]

B:BD[5.21302] → [9.10273:10630]

∅:D[9.10630] → [5.21428:22247]

B:BD[5.21428] → [5.21428:22247]

∅:D[10.699] → [5.22247:22318]

B:BD[5.22247] → [5.22247:22318]

B:BD[5.22318] → [10.700:808]

∅:D[10.808] → [5.22449:22585]

B:BD[5.22449] → [5.22449:22585]

B:BD[5.22585] → [10.809:842]

∅:D[10.842] → [5.23073:23078]

B:BD[5.23073] → [5.23073:23078]

B:BD[5.23078] → [10.843:950]

∅:D[10.950] → [5.23239:23294]

B:BD[5.23239] → [5.23239:23294]

B:BD[5.23294] → [10.951:1035]

∅:D[10.1035] → [5.23379:23527]

B:BD[5.23379] → [5.23379:23527]

B:BD[5.23527] → [10.1036:1067]

∅:D[10.1067] → [5.24043:24058]

B:BD[5.24043] → [5.24043:24058]

B:BD[5.24058] → [10.1068:1175]

∅:D[10.1175] → [5.24183:24319]

B:BD[5.24183] → [5.24183:24319]

B:BD[5.24319] → [10.1176:1208]

∅:D[10.1208] → [5.24804:24809]

B:BD[5.24804] → [5.24804:24809]

B:BD[5.24809] → [10.1209:1252]

∅:D[10.1252] → [5.24882:25022]

B:BD[5.24882] → [5.24882:25022]

B:BD[5.25022] → [10.1253:1292]

∅:D[10.1292] → [5.25114:25293]

B:BD[5.25114] → [5.25114:25293]

B:BD[5.25294] → [5.25294:25411]

B:BD[5.22247] → [10.6:699]

B:BD[5.16748] → [9.5778:5783]

package utils
import (
	"bytes"
	"encoding/binary"
	"fmt"
	"math"
	"os"
	"path/filepath"
	"testing"
	"time"
)
// createTestWAVFile creates a minimal valid WAV file for testing
func createTestWAVFile(t *testing.T, dir string, filename string, options struct {
	duration      float64
	sampleRate    int
	channels      int
	bitsPerSample int
	comment       string
	artist        string
}) string {
	t.Helper()
	path := filepath.Join(dir, filename)
	file, err := os.Create(path)
	if err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}
	defer file.Close()
	// Calculate data chunk size based on duration
	bytesPerSample := options.bitsPerSample / 8
	samplesPerSecond := options.sampleRate * options.channels
	dataSize := int(options.duration * float64(samplesPerSecond*bytesPerSample))
	// Calculate file size (excluding RIFF header)
	fileSize := 4 + 8 + 16 + 8 + dataSize // WAVE + fmt chunk + data chunk header
	// Add LIST INFO chunk size if metadata provided
	var infoChunk []byte
	if options.comment != "" || options.artist != "" {
		infoChunk = buildINFOChunk(options.comment, options.artist)
		fileSize += 8 + len(infoChunk) // LIST chunk header + content
	}
	buf := &bytes.Buffer{}
	// Write RIFF header
	buf.WriteString("RIFF")
	binary.Write(buf, binary.LittleEndian, uint32(fileSize))
	buf.WriteString("WAVE")
	// Write fmt chunk
	buf.WriteString("fmt ")
	binary.Write(buf, binary.LittleEndian, uint32(16)) // chunk size
	binary.Write(buf, binary.LittleEndian, uint16(1))  // audio format (PCM)
	binary.Write(buf, binary.LittleEndian, uint16(options.channels))
	binary.Write(buf, binary.LittleEndian, uint32(options.sampleRate))
	byteRate := options.sampleRate * options.channels * bytesPerSample
	binary.Write(buf, binary.LittleEndian, uint32(byteRate))
	blockAlign := options.channels * bytesPerSample
	binary.Write(buf, binary.LittleEndian, uint16(blockAlign))
	binary.Write(buf, binary.LittleEndian, uint16(options.bitsPerSample))
	// Write LIST INFO chunk if metadata provided
	if len(infoChunk) > 0 {
		buf.WriteString("LIST")
		binary.Write(buf, binary.LittleEndian, uint32(len(infoChunk)))
		buf.Write(infoChunk)
	}
	// Write data chunk
	buf.WriteString("data")
	binary.Write(buf, binary.LittleEndian, uint32(dataSize))
	// Write silence for data
	buf.Write(make([]byte, dataSize))
	// Write to file
	if _, err := file.Write(buf.Bytes()); err != nil {
		t.Fatalf("Failed to write test file: %v", err)
	}
	return path
}
// buildINFOChunk builds a LIST INFO chunk with optional comment and artist
func buildINFOChunk(comment, artist string) []byte {
	buf := &bytes.Buffer{}
	buf.WriteString("INFO")
	if comment != "" {
		buf.WriteString("ICMT")
		// Size includes null terminator
		size := len(comment) + 1
		binary.Write(buf, binary.LittleEndian, uint32(size))
		buf.WriteString(comment)
		buf.WriteByte(0) // null terminator
		// Add padding byte if needed for word alignment
		if size%2 != 0 {
			buf.WriteByte(0)
		}
	}
	if artist != "" {
		buf.WriteString("IART")
		size := len(artist) + 1
		binary.Write(buf, binary.LittleEndian, uint32(size))
		buf.WriteString(artist)
		buf.WriteByte(0) // null terminator
		if size%2 != 0 {
			buf.WriteByte(0)
		}
	}
	return buf.Bytes()
}
func TestConvertToFloat64_16Bit(t *testing.T) {
	// 16-bit signed, little-endian: 0x0001 = 1 → 1/32768
	data := []byte{0x01, 0x00, 0xFF, 0x7F}
	samples := convertToFloat64(data, 16, 1)
	if len(samples) != 2 {
		t.Fatalf("expected 2 samples, got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/32768.0) > 1e-10 {
		t.Errorf("sample[0] = %v, want %v", samples[0], 1.0/32768.0)
	}
	// 0x7FFF = 32767 → 32767/32768 ≈ 0.99997
	if math.Abs(samples[1]-32767.0/32768.0) > 1e-10 {
		t.Errorf("sample[1] = %v, want %v", samples[1], 32767.0/32768.0)
	}
}
func TestConvertToFloat64_16BitNegative(t *testing.T) {
	// 0x8000 = -32768 → -32768/32768 = -1.0
	data := []byte{0x00, 0x80}
	samples := convertToFloat64(data, 16, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-(-1.0)) > 1e-10 {
		t.Errorf("sample = %v, want -1.0", samples[0])
	}
}
func TestConvertToFloat64_16BitStereo(t *testing.T) {
	// Stereo: should extract only left channel
	// Left: 0x0001 = 1, Right: 0x0002 = 2
	data := []byte{0x01, 0x00, 0x02, 0x00}
	samples := convertToFloat64(data, 16, 2)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample (left only), got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/32768.0) > 1e-10 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/32768.0)
	}
}
func TestConvertToFloat64_24Bit(t *testing.T) {
	// 24-bit signed, little-endian: 0x000001 = 1 → 1/8388608
	data := []byte{0x01, 0x00, 0x00}
	samples := convertToFloat64(data, 24, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/8388608.0) > 1e-12 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/8388608.0)
	}
}
func TestConvertToFloat64_24BitNegative(t *testing.T) {
	// 24-bit: 0xFFFFFF = -1 (sign extended) → -1/8388608
	data := []byte{0xFF, 0xFF, 0xFF}
	samples := convertToFloat64(data, 24, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-(-1.0/8388608.0)) > 1e-12 {
		t.Errorf("sample = %v, want %v", samples[0], -1.0/8388608.0)
	}
}
func TestConvertToFloat64_24BitMaxPositive(t *testing.T) {
	// 24-bit max positive: 0x7FFFFF = 8388607 → ~0.9999999
	data := []byte{0xFF, 0xFF, 0x7F}
	samples := convertToFloat64(data, 24, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-8388607.0/8388608.0) > 1e-12 {
		t.Errorf("sample = %v, want %v", samples[0], 8388607.0/8388608.0)
	}
}
func TestConvertToFloat64_24BitMinNegative(t *testing.T) {
	// 24-bit min negative: 0x800000 = -8388608 → -1.0
	data := []byte{0x00, 0x00, 0x80}
	samples := convertToFloat64(data, 24, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-(-1.0)) > 1e-12 {
		t.Errorf("sample = %v, want -1.0", samples[0])
	}
}
func TestConvertToFloat64_24BitStereo(t *testing.T) {
	// 24-bit stereo: left=0x000001=1, right=0x000002=2
	data := []byte{0x01, 0x00, 0x00, 0x02, 0x00, 0x00}
	samples := convertToFloat64(data, 24, 2)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample (left only), got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/8388608.0) > 1e-12 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/8388608.0)
	}
}
func TestConvertToFloat64_32Bit(t *testing.T) {
	// 32-bit signed, little-endian: 0x00000001 = 1 → 1/2147483648
	data := []byte{0x01, 0x00, 0x00, 0x00}
	samples := convertToFloat64(data, 32, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/2147483648.0) > 1e-15 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/2147483648.0)
	}
}
func TestConvertToFloat64_32BitNegative(t *testing.T) {
	// 32-bit: 0x80000000 = -2147483648 → -1.0
	data := []byte{0x00, 0x00, 0x00, 0x80}
	samples := convertToFloat64(data, 32, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-(-1.0)) > 1e-15 {
		t.Errorf("sample = %v, want -1.0", samples[0])
	}
}
func TestConvertToFloat64_32BitMaxPositive(t *testing.T) {
	// 32-bit max positive: 0x7FFFFFFF = 2147483647 → ~0.9999999995
	data := []byte{0xFF, 0xFF, 0xFF, 0x7F}
	samples := convertToFloat64(data, 32, 1)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample, got %d", len(samples))
	}
	if math.Abs(samples[0]-2147483647.0/2147483648.0) > 1e-15 {
		t.Errorf("sample = %v, want %v", samples[0], 2147483647.0/2147483648.0)
	}
}
func TestConvertToFloat64_32BitStereo(t *testing.T) {
	// 32-bit stereo: left=1, right=2
	data := []byte{0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00}
	samples := convertToFloat64(data, 32, 2)
	if len(samples) != 1 {
		t.Fatalf("expected 1 sample (left only), got %d", len(samples))
	}
	if math.Abs(samples[0]-1.0/2147483648.0) > 1e-15 {
		t.Errorf("sample = %v, want %v", samples[0], 1.0/2147483648.0)
	}
}
func TestConvertToFloat64_UnsupportedBitDepth(t *testing.T) {
	// Unsupported bit depth (8) falls back to 16-bit parsing.
	// blockAlign = (8/8)*1 = 1, so numSamples = len(data)/1 = 4.
	// But 16-bit reads 2 bytes per sample, which panics with only 1 byte per block.
	// This tests the fallback path exists; for valid 8-bit data, blockAlign
	// must be 2 (so 2 bytes per sample in the data layout).
	data := []byte{0x01, 0x00, 0x02, 0x00}  // 4 bytes, treated as 2x 16-bit samples
	samples := convertToFloat64(data, 8, 2) // 2 channels → blockAlign = 1*2 = 2
	if len(samples) != 2 {
		t.Fatalf("expected 2 samples (fallback 16-bit), got %d", len(samples))
	}
}
func TestConvertToFloat64_EmptyData(t *testing.T) {
	samples := convertToFloat64([]byte{}, 16, 1)
	if len(samples) != 0 {
		t.Errorf("expected 0 samples, got %d", len(samples))
	}
}
func TestParseWAVHeader_BasicMetadata(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_basic.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      60.0,
		sampleRate:    44100,
		channels:      2,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.SampleRate != 44100 {
		t.Errorf("SampleRate incorrect: got %d, want 44100", metadata.SampleRate)
	}
	if metadata.Channels != 2 {
		t.Errorf("Channels incorrect: got %d, want 2", metadata.Channels)
	}
	if metadata.BitsPerSample != 16 {
		t.Errorf("BitsPerSample incorrect: got %d, want 16", metadata.BitsPerSample)
	}
	if metadata.Duration < 59.9 || metadata.Duration > 60.1 {
		t.Errorf("Duration incorrect: got %f, want ~60.0", metadata.Duration)
	}
}
func TestParseWAVHeader_CommentMetadata(t *testing.T) {
	tmpDir := t.TempDir()
	expectedComment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549"
	path := createTestWAVFile(t, tmpDir, "test_comment.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      10.0,
		sampleRate:    48000,
		channels:      1,
		bitsPerSample: 16,
		comment:       expectedComment,
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Comment != expectedComment {
		t.Errorf("Comment incorrect: got %q, want %q", metadata.Comment, expectedComment)
	}
}
func TestParseWAVHeader_ArtistMetadata(t *testing.T) {
	tmpDir := t.TempDir()
	expectedArtist := "AudioMoth"
	path := createTestWAVFile(t, tmpDir, "test_artist.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      5.0,
		sampleRate:    48000,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        expectedArtist,
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Artist != expectedArtist {
		t.Errorf("Artist incorrect: got %q, want %q", metadata.Artist, expectedArtist)
	}
}
func TestParseWAVHeader_CommentAndArtist(t *testing.T) {
	tmpDir := t.TempDir()
	expectedComment := "Test recording comment"
	expectedArtist := "Test Artist"
	path := createTestWAVFile(t, tmpDir, "test_both.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      15.0,
		sampleRate:    44100,
		channels:      2,
		bitsPerSample: 16,
		comment:       expectedComment,
		artist:        expectedArtist,
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Comment != expectedComment {
		t.Errorf("Comment incorrect: got %q, want %q", metadata.Comment, expectedComment)
	}
	if metadata.Artist != expectedArtist {
		t.Errorf("Artist incorrect: got %q, want %q", metadata.Artist, expectedArtist)
	}
}
func TestParseWAVHeader_SampleRates(t *testing.T) {
	tmpDir := t.TempDir()
	testCases := []int{8000, 16000, 22050, 44100, 48000, 96000}
	for _, sr := range testCases {
		t.Run(fmt.Sprintf("%dHz", sr), func(t *testing.T) {
			path := createTestWAVFile(t, tmpDir, fmt.Sprintf("test_sr_%d.wav", sr), struct {
				duration      float64
				sampleRate    int
				channels      int
				bitsPerSample int
				comment       string
				artist        string
			}{
				duration:      1.0,
				sampleRate:    sr,
				channels:      1,
				bitsPerSample: 16,
				comment:       "",
				artist:        "",
			})
			metadata, err := ParseWAVHeader(path)
			if err != nil {
				t.Fatalf("Failed to parse WAV header: %v", err)
			}
			if metadata.SampleRate != sr {
				t.Errorf("SampleRate incorrect: got %d, want %d", metadata.SampleRate, sr)
			}
		})
	}
}
func TestParseWAVHeader_ChannelCounts(t *testing.T) {
	tmpDir := t.TempDir()
	testCases := []int{1, 2}
	for _, ch := range testCases {
		t.Run(fmt.Sprintf("%dch", ch), func(t *testing.T) {
			path := createTestWAVFile(t, tmpDir, fmt.Sprintf("test_ch_%d.wav", ch), struct {
				duration      float64
				sampleRate    int
				channels      int
				bitsPerSample int
				comment       string
				artist        string
			}{
				duration:      1.0,
				sampleRate:    44100,
				channels:      ch,
				bitsPerSample: 16,
				comment:       "",
				artist:        "",
			})
			metadata, err := ParseWAVHeader(path)
			if err != nil {
				t.Fatalf("Failed to parse WAV header: %v", err)
			}
			if metadata.Channels != ch {
				t.Errorf("Channels incorrect: got %d, want %d", metadata.Channels, ch)
			}
		})
	}
}
func TestParseWAVHeader_BitDepths(t *testing.T) {
	tmpDir := t.TempDir()
	testCases := []int{8, 16, 24, 32}
	for _, bits := range testCases {
		t.Run(fmt.Sprintf("%dbit", bits), func(t *testing.T) {
			path := createTestWAVFile(t, tmpDir, fmt.Sprintf("test_bits_%d.wav", bits), struct {
				duration      float64
				sampleRate    int
				channels      int
				bitsPerSample int
				comment       string
				artist        string
			}{
				duration:      1.0,
				sampleRate:    44100,
				channels:      1,
				bitsPerSample: bits,
				comment:       "",
				artist:        "",
			})
			metadata, err := ParseWAVHeader(path)
			if err != nil {
				t.Fatalf("Failed to parse WAV header: %v", err)
			}
			if metadata.BitsPerSample != bits {
				t.Errorf("BitsPerSample incorrect: got %d, want %d", metadata.BitsPerSample, bits)
			}
		})
func TestParseWAVHeader_ShortDuration(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_short.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      0.1, // 100ms
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Duration < 0.09 || metadata.Duration > 0.11 {
		t.Errorf("Duration incorrect: got %f, want ~0.1", metadata.Duration)
	}
}
func TestParseWAVHeader_LongDuration(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_long.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      600.0, // 10 minutes
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Duration < 599.0 || metadata.Duration > 601.0 {
		t.Errorf("Duration incorrect: got %f, want ~600.0", metadata.Duration)
	}
}
func TestParseWAVHeader_NonExistentFile(t *testing.T) {
	_, err := ParseWAVHeader("/nonexistent/file.wav")
	if err == nil {
		t.Error("Expected error for non-existent file")
	}
}
func TestParseWAVHeader_NonWAVFile(t *testing.T) {
	tmpDir := t.TempDir()
	path := filepath.Join(tmpDir, "not_a_wav.txt")
	if err := os.WriteFile(path, []byte("This is not a WAV file"), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}
	_, err := ParseWAVHeader(path)
	if err == nil {
		t.Error("Expected error for non-WAV file")
	}
}
func TestParseWAVHeader_TruncatedFile(t *testing.T) {
	tmpDir := t.TempDir()
	path := filepath.Join(tmpDir, "truncated.wav")
	if err := os.WriteFile(path, []byte("RIFF"), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}
	_, err := ParseWAVHeader(path)
	if err == nil {
		t.Error("Expected error for truncated file")
	}
}
func TestParseWAVHeader_EmptyMetadataStrings(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_empty.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      10.0,
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Comment != "" {
		t.Errorf("Comment should be empty, got %q", metadata.Comment)
	}
	if metadata.Artist != "" {
		t.Errorf("Artist should be empty, got %q", metadata.Artist)
	}
}
func TestParseWAVHeader_LongCommentString(t *testing.T) {
	tmpDir := t.TempDir()
	longComment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C. This is a very long comment with additional information about the recording session."
	path := createTestWAVFile(t, tmpDir, "test_long_comment.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      10.0,
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       longComment,
		artist:        "",
	})
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if metadata.Comment != longComment {
		t.Errorf("Comment incorrect: got %q, want %q", metadata.Comment, longComment)
	}
}
func TestParseWAVHeader_FileModTime(t *testing.T) {
	tmpDir := t.TempDir()
	path := createTestWAVFile(t, tmpDir, "test_modtime.wav", struct {
		duration      float64
		sampleRate    int
		channels      int
		bitsPerSample int
		comment       string
		artist        string
	}{
		duration:      5.0,
		sampleRate:    44100,
		channels:      1,
		bitsPerSample: 16,
		comment:       "",
		artist:        "",
	})
	info, err := os.Stat(path)
	if err != nil {
		t.Fatalf("Failed to stat file: %v", err)
	}
	expectedModTime := info.ModTime()
	metadata, err := ParseWAVHeader(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	// Allow 1 second tolerance for filesystem granularity
	diff := metadata.FileModTime.Sub(expectedModTime)
	if diff < -1*time.Second || diff > 1*time.Second {
		t.Errorf("FileModTime incorrect: got %v, want %v (diff: %v)",
			metadata.FileModTime, expectedModTime, diff)
	}
	if metadata.FileModTime.IsZero() {
		t.Error("FileModTime should not be zero")
	}
}
func TestExtractNullTerminatedString(t *testing.T) {
	testCases := []struct {
		name     string
		input    []byte
		expected string
	}{
		{
			name:     "string with null terminator",
			input:    []byte{'h', 'e', 'l', 'l', 'o', 0, 'w', 'o', 'r', 'l', 'd'},
			expected: "hello",
		},
		{
			name:     "string without null terminator",
			input:    []byte{'h', 'e', 'l', 'l', 'o'},
			expected: "hello",
		},
		{
			name:     "empty string",
			input:    []byte{},
			expected: "",
		},
		{
			name:     "only null terminator",
			input:    []byte{0},
			expected: "",
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			result := extractNullTerminatedString(tc.input)
			if result != tc.expected {
				t.Errorf("Result incorrect: got %q, want %q", result, tc.expected)
			}
		})
	}
}
func TestParseWAVHeaderMinimal(t *testing.T) {
	tmpDir := t.TempDir()
	t.Run("basic", func(t *testing.T) {
		assertWAVHeader(t, tmpDir, "test_minimal.wav", 44100, 10.0, struct {
			duration      float64
			sampleRate    int
			channels      int
			bitsPerSample int
			comment       string
			artist        string
		}{10.0, 44100, 1, 16, "", ""})
	})
	t.Run("sample_rates", func(t *testing.T) {
		for _, sr := range []int{8000, 22050, 44100, 48000, 96000} {
			t.Run(fmt.Sprintf("%dHz", sr), func(t *testing.T) {
				assertWAVHeader(t, tmpDir, fmt.Sprintf("test_sr_%d.wav", sr), sr, 5.0, struct {
					duration      float64
					sampleRate    int
					channels      int
					bitsPerSample int
					comment       string
					artist        string
				}{5.0, sr, 1, 16, "", ""})
			})
		}
	})
	t.Run("stereo", func(t *testing.T) {
		assertWAVHeader(t, tmpDir, "test_stereo.wav", 44100, 3.0, struct {
			duration      float64
			sampleRate    int
			channels      int
			bitsPerSample int
			comment       string
			artist        string
		}{3.0, 44100, 2, 16, "", ""})
	})
	t.Run("nonexistent", func(t *testing.T) {
		_, _, err := ParseWAVHeaderMinimal("/nonexistent/file.wav")
		if err == nil {
			t.Error("Expected error for non-existent file")
		}
	})
	t.Run("non_wav", func(t *testing.T) {
		path := filepath.Join(tmpDir, "notawav.wav")
		if err := os.WriteFile(path, []byte("Not a WAV file"), 0644); err != nil {
			t.Fatalf("Failed to create test file: %v", err)
		}
		_, _, err := ParseWAVHeaderMinimal(path)
		if err == nil {
			t.Error("Expected error for non-WAV file")
		}
	})
}
// assertWAVHeader creates a WAV file and verifies ParseWAVHeaderMinimal returns expected values.
func assertWAVHeader(t *testing.T, tmpDir, filename string, wantSR int, wantDur float64, opts struct {
	duration      float64
	sampleRate    int
	channels      int
	bitsPerSample int
	comment       string
	artist        string
}) {
	t.Helper()
	path := createTestWAVFile(t, tmpDir, filename, opts)
	sr, dur, err := ParseWAVHeaderMinimal(path)
	if err != nil {
		t.Fatalf("Failed to parse WAV header: %v", err)
	}
	if sr != wantSR {
		t.Errorf("SampleRate: got %d, want %d", sr, wantSR)
	}
	if dur < wantDur-0.1 || dur > wantDur+0.1 {
		t.Errorf("Duration: got %f, want ~%f", dur, wantDur)
	}
}
	}
}

File deletion: wav_metadata.go

BF:BFD[5.1] → [5.40953:40992]

BF:BFD[5.40992] → [5.25458:25458]

B:BD[5.25458] → [5.25459:27177]

B:BD[5.27177] → [11.7:268]

∅:D[11.268] → [5.27510:27657]

B:BD[5.27510] → [5.27510:27657]

B:BD[5.27697] → [5.27697:27808]

B:BD[5.27868] → [5.27868:27869]

B:BD[5.27869] → [11.269:344]

∅:D[11.344] → [5.28024:28025]

B:BD[5.28024] → [5.28024:28025]

B:BD[5.28025] → [11.345:371]

∅:D[11.371] → [5.28129:28225]

B:BD[5.28129] → [5.28129:28225]

B:BD[5.28225] → [11.372:387]

∅:D[11.387] → [5.28252:28253]

B:BD[5.28252] → [5.28252:28253]

B:BD[5.28253] → [11.388:429]

∅:D[11.429] → [5.28300:28338]

B:BD[5.28300] → [5.28300:28338]

B:BD[5.28441] → [5.28441:28442]

∅:D[11.510] → [5.28442:28464]

B:BD[5.28442] → [5.28442:28464]

∅:D[11.819] → [5.28464:28917]

B:BD[5.28464] → [5.28464:28917]

B:BD[5.28917] → [11.820:915]

∅:D[11.915] → [5.29566:29605]

B:BD[5.29566] → [5.29566:29605]

B:BD[5.31394] → [12.221:273]

∅:D[12.273] → [5.31565:31914]

B:BD[5.31565] → [5.31565:31914]

∅:D[11.1040] → [5.31914:32065]

B:BD[5.31914] → [5.31914:32065]

B:BD[5.32114] → [5.32114:32229]

B:BD[5.32289] → [5.32289:32290]

B:BD[5.32322] → [5.32322:32446]

B:BD[5.32486] → [5.32486:32646]

B:BD[5.32663] → [5.32663:32752]

B:BD[5.32752] → [11.1041:1121]

∅:D[11.1121] → [5.32814:32971]

B:BD[5.32814] → [5.32814:32971]

B:BD[5.33001] → [5.33001:33518]

B:BD[5.33542] → [5.33542:33650]

B:BD[5.33674] → [5.33674:33812]

B:BD[5.33830] → [5.33830:33872]

B:BD[5.33900] → [5.33900:34068]

B:BD[5.34068] → [13.7:64]

∅:D[13.64] → [5.34440:34455]

B:BD[5.34440] → [5.34440:34455]

B:BD[5.34455] → [13.65:111]

∅:D[13.111] → [5.34972:34987]

B:BD[5.34972] → [5.34972:34987]

B:BD[5.34987] → [13.112:170]

∅:D[13.170] → [5.35234:35239]

B:BD[5.35234] → [5.35234:35239]

B:BD[5.35289] → [5.35289:35335]

B:BD[5.35335] → [13.171:183]

∅:D[13.183] → [5.35368:35376]

B:BD[5.35368] → [5.35368:35376]

B:BD[5.35420] → [5.35420:35637]

∅:D[13.208] → [5.35637:35638]

B:BD[5.35637] → [5.35637:35638]

B:BD[5.35638] → [13.209:958]

∅:D[13.958] → [5.35660:35663]

B:BD[5.35660] → [5.35660:35663]

∅:D[13.1221] → [5.35663:36719]

B:BD[5.35663] → [5.35663:36719]

B:BD[5.36719] → [14.7:201]

∅:D[14.201] → [5.37149:37150]

B:BD[5.37149] → [5.37149:37150]

B:BD[5.37150] → [14.202:442]

∅:D[14.442] → [5.37743:37880]

B:BD[5.37743] → [5.37743:37880]

B:BD[5.37880] → [14.443:510]

∅:D[14.510] → [5.37949:38189]

B:BD[5.37949] → [5.37949:38189]

B:BD[5.38189] → [14.511:576]

∅:D[14.576] → [5.38256:38288]

B:BD[5.38256] → [5.38256:38288]

B:BD[5.38288] → [14.577:784]

∅:D[14.784] → [5.38480:38485]

B:BD[5.38480] → [5.38480:38485]

B:BD[5.38486] → [5.38486:38501]

B:BD[5.38501] → [14.785:887]

∅:D[14.887] → [5.38636:38647]

B:BD[5.38636] → [5.38636:38647]

B:BD[5.38647] → [15.3123:3190]

B:BD[15.3190] → [14.888:949]

∅:D[14.949] → [5.38789:38839]

B:BD[5.38789] → [5.38789:38839]

B:BD[5.38839] → [15.3191:3250]

B:BD[15.3250] → [14.950:1013]

∅:D[14.1013] → [5.38950:38962]

B:BD[5.38950] → [5.38950:38962]

∅:D[14.1076] → [5.38962:38963]

B:BD[5.38962] → [5.38962:38963]

B:BD[5.38963] → [14.1077:1347]

∅:D[14.1347] → [5.39025:39026]

B:BD[5.39025] → [5.39025:39026]

B:BD[15.3376] → [15.3376:3395]

B:BD[15.3395] → [14.1348:1474]

∅:D[16.1191] → [5.39298:39302]

∅:D[14.1474] → [5.39298:39302]

∅:D[15.3558] → [5.39298:39302]

B:BD[5.39298] → [5.39298:39302]

B:BD[5.39302] → [15.3559:3576]

B:BD[15.3576] → [14.1475:1594]

∅:D[16.1250] → [15.3728:3797]

∅:D[14.1594] → [15.3728:3797]

B:BD[15.3728] → [15.3728:3797]

B:BD[15.3824] → [15.3824:3838]

B:BD[15.3838] → [14.1595:1650]

B:BD[14.1650] → [17.7:154]

B:BD[17.154] → [2.7:115]

∅:D[2.115] → [14.1964:1981]

B:BD[14.1964] → [14.1964:1981]

B:BD[14.1981] → [17.224:297]

∅:D[17.297] → [14.2041:2044]

B:BD[14.2041] → [14.2041:2044]

B:BD[14.2044] → [2.116:176]

∅:D[2.176] → [14.2081:2113]

B:BD[14.2081] → [14.2081:2113]

B:BD[14.2113] → [2.177:230]

∅:D[2.230] → [17.313:388]

B:BD[17.313] → [17.313:388]

∅:D[17.388] → [14.2232:2311]

B:BD[14.2232] → [14.2232:2311]

B:BD[17.404] → [17.404:469]

∅:D[17.469] → [14.2363:2367]

B:BD[14.2363] → [14.2363:2367]

B:BD[14.2367] → [2.231:272]

∅:D[2.272] → [17.485:553]

B:BD[17.485] → [17.485:553]

∅:D[17.553] → [14.2467:2471]

B:BD[14.2467] → [14.2467:2471]

B:BD[14.2471] → [2.273:304]

∅:D[2.304] → [14.2506:2523]

B:BD[14.2506] → [14.2506:2523]

B:BD[17.569] → [17.569:603]

∅:D[17.603] → [15.3874:3877]

∅:D[14.2544] → [15.3874:3877]

B:BD[15.3874] → [15.3874:3877]

∅:D[14.2684] → [15.3877:3878]

B:BD[15.3877] → [15.3877:3878]

∅:D[17.894] → [15.3878:3898]

∅:D[14.2752] → [15.3878:3898]

B:BD[15.3878] → [15.3878:3898]

B:BD[15.3898] → [17.895:913]

∅:D[17.913] → [15.3936:3940]

∅:D[14.2796] → [15.3936:3940]

B:BD[15.3936] → [15.3936:3940]

B:BD[15.3940] → [14.2797:2878]

B:BD[14.2878] → [17.914:982]

∅:D[17.982] → [15.4087:4128]

B:BD[15.4087] → [15.4087:4128]

∅:D[15.4128] → [5.39339:39396]

B:BD[5.39339] → [5.39339:39396]

B:BD[15.4187] → [15.4187:4238]

B:BD[15.4238] → [17.983:1047]

∅:D[17.1047] → [15.4305:4309]

B:BD[15.4305] → [15.4305:4309]

∅:D[15.4309] → [5.39462:39465]

B:BD[5.39462] → [5.39462:39465]

B:BD[5.39465] → [17.1048:1073]

∅:D[17.1073] → [5.39562:39563]

B:BD[5.39562] → [5.39562:39563]

∅:D[17.1725] → [14.2879:2992]

B:BD[5.39563] → [14.2879:2992]

∅:D[14.2992] → [5.39596:39599]

B:BD[5.39596] → [5.39596:39599]

∅:D[15.4640] → [5.39599:40952]

B:BD[5.39599] → [5.39599:40952]

B:BD[5.39599] → [15.4310:4640]

B:BD[5.39563] → [17.1074:1725]

B:BD[15.3878] → [2.305:326]

∅:D[2.326] → [17.717:894]

B:BD[17.717] → [17.717:894]

B:BD[15.3877] → [14.2545:2621]

B:BD[17.619] → [17.619:692]

∅:D[17.692] → [14.2681:2684]

B:BD[14.2681] → [14.2681:2684]

B:BD[5.38962] → [14.1014:1076]

B:BD[5.35663] → [13.959:1221]

B:BD[5.35637] → [13.184:208]

B:BD[5.31914] → [11.916:1040]

B:BD[5.28464] → [11.511:819]

B:BD[5.28442] → [11.430:510]

package utils
import (
	"bytes"
	"encoding/binary"
	"fmt"
	"io"
	"os"
	"sync"
	"time"
	"github.com/cespare/xxhash/v2"
)
// Buffer pools for reducing GC pressure during batch imports
var (
	// headerBufferPool stores 200KB buffers for WAV header reading (full metadata)
	headerBufferPool = sync.Pool{
		New: func() any {
			buf := make([]byte, 200*1024)
			return &buf
		},
	}
	// minimalHeaderBufferPool stores 4KB buffers for minimal WAV header reading
	// 4KB is sufficient for fmt + data chunk headers in 99% of WAV files
	minimalHeaderBufferPool = sync.Pool{
		New: func() any {
			buf := make([]byte, 4*1024)
			return &buf
		},
	}
)
// getHeaderBuffer gets a 200KB buffer from the pool
func getHeaderBuffer() *[]byte {
	return headerBufferPool.Get().(*[]byte)
}
// putHeaderBuffer returns a 200KB buffer to the pool
func putHeaderBuffer(buf *[]byte) {
	headerBufferPool.Put(buf)
}
// getMinimalHeaderBuffer gets a 4KB buffer from the pool
func getMinimalHeaderBuffer() *[]byte {
	return minimalHeaderBufferPool.Get().(*[]byte)
}
// putMinimalHeaderBuffer returns a 4KB buffer to the pool
func putMinimalHeaderBuffer(buf *[]byte) {
	minimalHeaderBufferPool.Put(buf)
}
// WAVMetadata contains metadata extracted from WAV file headers
type WAVMetadata struct {
	Duration      float64   // Duration in seconds
	SampleRate    int       // Sample rate in Hz
	Comment       string    // Comment from INFO chunk (may contain AudioMoth data)
	Artist        string    // Artist from INFO chunk
	Channels      int       // Number of audio channels
	BitsPerSample int       // Bits per sample
	FileModTime   time.Time // File modification time (fallback timestamp)
	FileSize      int64     // File size in bytes
}
// readAndParseHeader opens a WAV file, reads its header using the provided buffer pool,
// parses metadata, and sets file modification time and size.
func readAndParseHeader(filepath string, getBuf func() *[]byte, putBuf func(*[]byte)) (*WAVMetadata, error) {
	file, err := os.Open(filepath)
	if err != nil {
		return nil, fmt.Errorf("failed to open file: %w", err)
	}
	defer func() { _ = file.Close() }()
	fileInfo, err := file.Stat()
	if err != nil {
		return nil, fmt.Errorf("failed to get file info: %w", err)
	}
	bufPtr := getBuf()
	defer putBuf(bufPtr)
	buf := (*bufPtr)[:cap(*bufPtr)]
	n, err := file.Read(buf)
	if err != nil && err != io.EOF {
		return nil, fmt.Errorf("failed to read header: %w", err)
	}
	buf = buf[:n]
	metadata, err := parseWAVFromBytes(buf)
	if err != nil {
		return nil, err
	}
	return metadata, nil
}
// ParseWAVHeaderMinimal reads only the first 4KB of a WAV file to extract essential metadata.
// This is optimized for batch processing where INFO chunks (comment/artist) are not needed.
// It's ~50x faster than ParseWAVHeader for large files due to reduced I/O.
// Returns (sampleRate, duration, error) - the minimal data needed for .data file generation.
func ParseWAVHeaderMinimal(filepath string) (sampleRate int, duration float64, err error) {
	metadata, err := readAndParseHeader(filepath, getMinimalHeaderBuffer, putMinimalHeaderBuffer)
	if err != nil {
		return 0, 0, err
	}
	return metadata.SampleRate, metadata.Duration, nil
}
// ParseWAVHeaderWithHash reads the WAV file once to extract both metadata and hash.
// This is more efficient than calling ParseWAVHeader and ComputeXXH64 separately,
// as it only opens the file once and reads it in a single pass.
// Returns (metadata, hash, error).
func ParseWAVHeaderWithHash(filepath string) (*WAVMetadata, string, error) {
	file, err := os.Open(filepath)
	if err != nil {
		return nil, "", fmt.Errorf("failed to open file: %w", err)
	}
	defer func() { _ = file.Close() }()
	fileInfo, err := file.Stat()
	if err != nil {
		return nil, "", fmt.Errorf("failed to get file info: %w", err)
	}
	headerBufPtr := getHeaderBuffer()
	defer putHeaderBuffer(headerBufPtr)
	headerBuf := (*headerBufPtr)[:cap(*headerBufPtr)]
	n, err := file.Read(headerBuf)
	if err != nil && err != io.EOF {
		return nil, "", fmt.Errorf("failed to read header: %w", err)
	}
	headerBuf = headerBuf[:n]
	metadata, err := parseWAVFromBytes(headerBuf)
	if err != nil {
		return nil, "", err
	}
	metadata.FileModTime = fileInfo.ModTime()
	metadata.FileSize = fileInfo.Size()
	// Hash: seek back to start and stream entire file
	if _, err := file.Seek(0, 0); err != nil {
		return nil, "", fmt.Errorf("failed to seek: %w", err)
	}
	hashBufPtr := getHashBuffer()
	defer putHashBuffer(hashBufPtr)
	hashBuf := *hashBufPtr
	h := xxhash.New()
	if _, err := io.CopyBuffer(h, file, hashBuf); err != nil {
		return nil, "", fmt.Errorf("failed to read file for hash: %w", err)
	}
	hash := fmt.Sprintf("%016x", h.Sum64())
	return metadata, hash, nil
}
// parseWAVFromBytes parses WAV metadata from a byte buffer
func parseWAVFromBytes(data []byte) (*WAVMetadata, error) {
	if len(data) < 44 {
		return nil, fmt.Errorf("file too small to be valid WAV")
	}
	if string(data[0:4]) != "RIFF" {
		return nil, fmt.Errorf("not a valid WAV file (missing RIFF header)")
	}
	if string(data[8:12]) != "WAVE" {
		return nil, fmt.Errorf("not a valid WAV file (missing WAVE format)")
	}
	metadata := &WAVMetadata{}
	offset := 12
	for offset < len(data)-8 {
		chunkID := string(data[offset : offset+4])
		chunkSize := int(binary.LittleEndian.Uint32(data[offset+4 : offset+8]))
		offset += 8
		switch chunkID {
		case "fmt ":
			parseFmtChunkData(data[offset:], chunkSize, metadata)
		case "data":
			calcDataChunkDuration(chunkSize, metadata)
		case "LIST":
			parseLISTChunkData(data[offset:], chunkSize, metadata)
		}
		offset += chunkSize
		if chunkSize%2 != 0 {
			offset++
		}
	}
	if metadata.SampleRate == 0 {
		return nil, fmt.Errorf("invalid WAV file: missing or corrupt fmt chunk")
	}
	if metadata.Duration == 0 {
		return nil, fmt.Errorf("invalid WAV file: missing or corrupt data chunk")
	}
// parseFmtChunkData extracts format info from a fmt chunk.
func parseFmtChunkData(data []byte, chunkSize int, m *WAVMetadata) {
	if chunkSize >= 16 && len(data) >= 16 {
		m.Channels = int(binary.LittleEndian.Uint16(data[2:4]))
		m.SampleRate = int(binary.LittleEndian.Uint32(data[4:8]))
		m.BitsPerSample = int(binary.LittleEndian.Uint16(data[14:16]))
	}
}
// calcDataChunkDuration computes duration from the data chunk size.
func calcDataChunkDuration(chunkSize int, m *WAVMetadata) {
	if m.SampleRate > 0 && m.Channels > 0 && m.BitsPerSample > 0 {
		bytesPerSample := m.BitsPerSample / 8
		bytesPerSecond := m.SampleRate * m.Channels * bytesPerSample
		if bytesPerSecond > 0 {
			m.Duration = float64(chunkSize) / float64(bytesPerSecond)
		}
	}
}
// parseINFOChunk parses INFO list chunk for comment and artist metadata
func parseINFOChunk(data []byte, metadata *WAVMetadata) {
	offset := 0
	for offset < len(data)-8 {
		// Read subchunk ID and size
		if offset+8 > len(data) {
			break
		}
		subchunkID := string(data[offset : offset+4])
		subchunkSize := int(binary.LittleEndian.Uint32(data[offset+4 : offset+8]))
		offset += 8
		if offset+subchunkSize > len(data) {
			break
		}
		// Extract null-terminated string
		value := extractNullTerminatedString(data[offset : offset+subchunkSize])
		switch subchunkID {
		case "ICMT": // Comment
			metadata.Comment = value
		case "IART": // Artist
			metadata.Artist = value
		}
		// Move to next subchunk (word-aligned)
		offset += subchunkSize
		if subchunkSize%2 != 0 {
			offset++ // Skip padding byte
		}
	}
}
// extractNullTerminatedString extracts a null-terminated string from bytes
func extractNullTerminatedString(data []byte) string {
	before, _, ok := bytes.Cut(data, []byte{0})
	if ok {
		return string(before)
	}
	return string(data)
}
// wavChunkInfo holds parsed WAV format and data chunk locations.
type wavChunkInfo struct {
	sampleRate    int
	channels      int
	bitsPerSample int
	dataOffset    int64
	dataSize      int64
}
// parseWAVChunks reads WAV chunks from the current file position, returning
// format info and data chunk location. Returns error if no data chunk is found.
func parseWAVChunks(file *os.File) (wavChunkInfo, error) {
	var info wavChunkInfo
	for {
		chunkHeader := make([]byte, 8)
		if _, err := io.ReadFull(file, chunkHeader); err != nil {
			if err == io.EOF {
				break
			}
			return info, fmt.Errorf("failed to read chunk header: %w", err)
		}
		chunkID := string(chunkHeader[0:4])
		chunkSize := int64(binary.LittleEndian.Uint32(chunkHeader[4:8]))
		switch chunkID {
		case "fmt ":
			fmtData := make([]byte, chunkSize)
			if _, err := io.ReadFull(file, fmtData); err != nil {
				return info, fmt.Errorf("failed to read fmt chunk: %w", err)
			}
			if len(fmtData) >= 16 {
				info.channels = int(binary.LittleEndian.Uint16(fmtData[2:4]))
				info.sampleRate = int(binary.LittleEndian.Uint32(fmtData[4:8]))
				info.bitsPerSample = int(binary.LittleEndian.Uint16(fmtData[14:16]))
			}
		case "data":
			info.dataOffset, _ = file.Seek(0, io.SeekCurrent)
			info.dataSize = chunkSize
			return info, nil
		default:
			if _, err := file.Seek(chunkSize, io.SeekCurrent); err != nil {
				return info, fmt.Errorf("failed to skip chunk: %w", err)
			}
		}
		// Word align
		if chunkSize%2 != 0 {
			if _, err := file.Seek(1, io.SeekCurrent); err != nil {
				return info, fmt.Errorf("failed to skip padding: %w", err)
			}
		}
	}
// calcWAVReadRange computes the byte offset and size to read from the data chunk.
func calcWAVReadRange(startSec, endSec float64, info wavChunkInfo) (startOffset, readSize int64) {
	bytesPerSample := info.bitsPerSample / 8
	blockAlign := bytesPerSample * info.channels
	if startSec > 0 {
		startSample := int64(startSec * float64(info.sampleRate))
		startOffset = min(startSample*int64(blockAlign), info.dataSize)
	}
	if endSec > 0 {
		endSample := int64(endSec * float64(info.sampleRate))
		endOffset := min(endSample*int64(blockAlign), info.dataSize)
		if endOffset > startOffset {
			readSize = endOffset - startOffset
		}
	} else {
		readSize = info.dataSize - startOffset
	}
	return
}
// parseWAVInfo opens a WAV file, validates its header, and parses chunks.
// Returns the parsed chunk info and the open file (caller must close).
func parseWAVInfo(filepath string) (f *os.File, info wavChunkInfo, err error) {
	f, err = os.Open(filepath)
	if err != nil {
		return nil, wavChunkInfo{}, fmt.Errorf("failed to open file: %w", err)
	}
	defer func() {
		if err != nil {
			_ = f.Close()
		}
	}()
	headerBuf := make([]byte, 44)
	if _, err = io.ReadFull(f, headerBuf); err != nil {
		return nil, wavChunkInfo{}, fmt.Errorf("failed to read header: %w", err)
	}
	if string(headerBuf[0:4]) != "RIFF" || string(headerBuf[8:12]) != "WAVE" {
		return nil, wavChunkInfo{}, fmt.Errorf("not a valid WAV file")
	}
	if _, err = f.Seek(12, 0); err != nil {
		return nil, wavChunkInfo{}, fmt.Errorf("failed to seek: %w", err)
	}
	info, err = parseWAVChunks(f)
	if err != nil {
		return nil, wavChunkInfo{}, err
	}
	if readSize == 0 {
		return nil, nil
	}
	if _, err := file.Seek(info.dataOffset+startOffset, io.SeekStart); err != nil {
		return nil, fmt.Errorf("failed to seek to data segment: %w", err)
	}
	audioData := make([]byte, readSize)
	if _, err := io.ReadFull(file, audioData); err != nil {
		if err != io.EOF && err != io.ErrUnexpectedEOF {
			return nil, fmt.Errorf("failed to read audio data: %w", err)
		}
	}
	return audioData, nil
}
	samples := convertToFloat64(audioData, info.bitsPerSample, info.channels)
	return samples, info.sampleRate, nil
}
// convertToFloat64 converts raw audio bytes to float64 samples
// Returns mono (left channel only for stereo)
func convertToFloat64(data []byte, bitsPerSample, channels int) []float64 {
	bytesPerSample := bitsPerSample / 8
	blockAlign := bytesPerSample * channels
	numSamples := len(data) / blockAlign
	samples := make([]float64, numSamples)
	switch bitsPerSample {
	case 16:
		for i := range numSamples {
			// Read first (left) channel only for stereo
			offset := i * blockAlign
			sample := int16(binary.LittleEndian.Uint16(data[offset : offset+2]))
			samples[i] = float64(sample) / 32768.0
		}
	case 24:
		for i := range numSamples {
			offset := i * blockAlign
			// 24-bit signed, little-endian
			b := data[offset : offset+3]
			sample := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16
			// Sign extend
			if sample >= 0x800000 {
				sample -= 0x1000000
			}
			samples[i] = float64(sample) / 8388608.0
		}
	case 32:
		for i := range numSamples {
			offset := i * blockAlign
			sample := int32(binary.LittleEndian.Uint32(data[offset : offset+4]))
			samples[i] = float64(sample) / 2147483648.0
		}
	default:
		// Fallback: treat as 16-bit
		for i := range numSamples {
			offset := i * blockAlign
			sample := int16(binary.LittleEndian.Uint16(data[offset : offset+2]))
			samples[i] = float64(sample) / 32768.0
		}
	}
	return samples
}
// ReadWAVSamples reads audio samples from a WAV file and returns them as float64.
// Mono files: returns single channel.
// Stereo files: returns left channel only.
// Samples are normalized to the range -1.0 to 1.0.
func ReadWAVSamples(filepath string) ([]float64, int, error) {
	return ReadWAVSegmentSamples(filepath, 0, 0)
}
// ReadWAVSegmentSamples reads a specific time range of audio samples from a WAV file.
// If startSec < 0, it starts from 0.
// If endSec <= 0 or endSec > duration, it reads to the end.
func ReadWAVSegmentSamples(filepath string, startSec, endSec float64) ([]float64, int, error) {
	file, info, err := parseWAVInfo(filepath)
	if err != nil {
		return nil, 0, err
	}
	defer func() { _ = file.Close() }()
	startOffset, readSize := calcWAVReadRange(startSec, endSec, info)
	audioData, err := readAudioSegment(file, info, startOffset, readSize)
	if err != nil {
		return nil, 0, err
	}
	if readSize == 0 {
		return []float64{}, info.sampleRate, nil
	}
	return f, info, nil
}
// readAudioSegment reads audio bytes from an already-parsed WAV file.
func readAudioSegment(file *os.File, info wavChunkInfo, startOffset, readSize int64) ([]byte, error) {
	if info.sampleRate == 0 || info.channels == 0 || info.bitsPerSample == 0 {
		return nil, wavChunkInfo{}, fmt.Errorf("missing or invalid fmt chunk")
	}
	return info, fmt.Errorf("no data chunk found in WAV file")
}
// parseLISTChunkData parses a LIST chunk for INFO metadata.
func parseLISTChunkData(data []byte, chunkSize int, m *WAVMetadata) {
	if chunkSize >= 4 && len(data) >= chunkSize {
		if string(data[:4]) == "INFO" {
			parseINFOChunk(data[4:chunkSize], m)
		}
	}
}
	return metadata, nil
}
	// Use readAndParseHeader for the header portion, but we need the file handle
	// for hashing, so we can't fully delegate.
}
// ParseWAVHeader efficiently reads only the WAV file header to extract metadata.
// It reads the first 200KB of the file, which should be sufficient for all header chunks.
func ParseWAVHeader(filepath string) (*WAVMetadata, error) {
	return readAndParseHeader(filepath, getHeaderBuffer, putHeaderBuffer)
	metadata.FileModTime = fileInfo.ModTime()
	metadata.FileSize = fileInfo.Size()

File deletion: audiomoth_parser_test.go

BF:BFD[5.1] → [5.206837:206885]

BF:BFD[5.206885] → [5.194786:194786]

B:BD[5.194786] → [5.194787:194811]

B:BD[5.194824] → [5.194824:196030]

B:BD[5.196030] → [18.41:486]

∅:D[18.486] → [5.196262:196263]

B:BD[5.196262] → [5.196262:196263]

B:BD[5.196263] → [18.487:685]

∅:D[18.685] → [5.196381:196382]

B:BD[5.196381] → [5.196381:196382]

B:BD[5.196382] → [18.686:800]

∅:D[18.800] → [5.196635:196636]

B:BD[5.196635] → [5.196635:196636]

B:BD[5.196636] → [18.801:1007]

∅:D[18.1007] → [5.196870:196871]

B:BD[5.196870] → [5.196870:196871]

B:BD[5.196871] → [18.1008:1206]

∅:D[18.1206] → [5.197008:197009]

B:BD[5.197008] → [5.197008:197009]

B:BD[5.197009] → [18.1207:1341]

∅:D[19.4092] → [18.1450:1648]

B:BD[18.1450] → [18.1450:1648]

∅:D[18.1648] → [5.197124:197125]

B:BD[5.197124] → [5.197124:197125]

B:BD[5.197125] → [18.1649:1857]

∅:D[18.1857] → [5.197228:197229]

B:BD[5.197228] → [5.197228:197229]

B:BD[5.197229] → [18.1858:2025]

∅:D[18.2025] → [5.197321:197325]

B:BD[5.197321] → [5.197321:197325]

B:BD[5.197325] → [18.2026:2031]

∅:D[18.2031] → [5.197329:197330]

B:BD[5.197329] → [5.197329:197330]

B:BD[5.197330] → [18.2032:2233]

∅:D[18.2233] → [5.197571:197572]

B:BD[5.197571] → [5.197571:197572]

B:BD[5.197572] → [18.2234:2356]

∅:D[18.2356] → [5.197756:197757]

B:BD[5.197756] → [5.197756:197757]

B:BD[5.197757] → [18.2357:2564]

∅:D[19.4192] → [18.2669:2867]

B:BD[18.2669] → [18.2669:2867]

∅:D[18.2867] → [5.198573:198574]

B:BD[5.198573] → [5.198573:198574]

B:BD[5.198574] → [18.2868:2955]

∅:D[19.4214] → [18.2979:2983]

B:BD[18.2979] → [18.2979:2983]

∅:D[19.4351] → [18.3134:3137]

B:BD[18.3134] → [18.3134:3137]

∅:D[18.3137] → [5.198970:198971]

B:BD[5.198970] → [5.198970:198971]

B:BD[5.198971] → [18.3138:3333]

∅:D[18.3333] → [5.199690:199756]

B:BD[5.199690] → [5.199690:199756]

B:BD[5.199756] → [18.3334:3419]

∅:D[18.3419] → [5.199804:199808]

B:BD[5.199804] → [5.199804:199808]

B:BD[5.199808] → [18.3420:3546]

∅:D[18.3546] → [5.199901:199905]

B:BD[5.199901] → [5.199901:199905]

B:BD[5.199905] → [18.3547:3552]

∅:D[18.3552] → [5.199909:199910]

B:BD[5.199909] → [5.199909:199910]

B:BD[5.199910] → [18.3553:3956]

∅:D[18.3956] → [5.200239:200240]

B:BD[5.200239] → [5.200239:200240]

B:BD[5.200240] → [18.3957:4151]

∅:D[18.4151] → [5.200453:200454]

B:BD[5.200453] → [5.200453:200454]

B:BD[5.200454] → [18.4152:4292]

∅:D[18.4292] → [5.200638:200642]

B:BD[5.200638] → [5.200638:200642]

B:BD[5.200642] → [18.4293:4296]

∅:D[18.4296] → [5.200646:200732]

B:BD[5.200646] → [5.200646:200732]

∅:D[19.4373] → [5.200756:200776]

B:BD[5.200756] → [5.200756:200776]

∅:D[19.4603] → [5.201026:205416]

B:BD[5.201026] → [5.201026:205416]

∅:D[19.4722] → [5.205540:206836]

B:BD[5.205540] → [5.205540:206836]

B:BD[5.205416] → [19.4604:4722]

B:BD[5.200776] → [19.4374:4603]

B:BD[5.200732] → [19.4352:4373]

B:BD[18.2983] → [19.4215:4351]

B:BD[18.2955] → [19.4193:4214]

B:BD[18.2564] → [19.4093:4192]

B:BD[18.1341] → [19.3989:4092]

package utils
import (
	"strings"
	"testing"
	"time"
)
func TestIsAudioMoth(t *testing.T) {
	t.Run("should identify AudioMoth files by artist field", func(t *testing.T) {
		if !IsAudioMoth("", "AudioMoth") {
			t.Error("Should identify AudioMoth by artist field")
		}
		if !IsAudioMoth("", "AudioMoth 123456") {
			t.Error("Should identify AudioMoth with ID in artist field")
		}
		if IsAudioMoth("", "Other Artist") {
			t.Error("Should not identify non-AudioMoth artist")
		}
	})
	t.Run("should identify AudioMoth files by comment field", func(t *testing.T) {
		if !IsAudioMoth("Recorded by AudioMoth...", "") {
			t.Error("Should identify AudioMoth by comment field")
		}
		if IsAudioMoth("Regular recording comment", "") {
			t.Error("Should not identify non-AudioMoth comment")
		}
	})
	t.Run("should handle missing metadata", func(t *testing.T) {
		if IsAudioMoth("", "") {
			t.Error("Should not identify empty strings as AudioMoth")
		}
	})
	t.Run("should be case insensitive", func(t *testing.T) {
		if !IsAudioMoth("", "audiomoth") {
			t.Error("Should be case insensitive")
		}
		if !IsAudioMoth("", "AUDIOMOTH") {
			t.Error("Should be case insensitive")
		}
	})
}
func TestParseAudioMothComment(t *testing.T) {
	t.Run("should parse a valid structured AudioMoth comment", testParseStructuredComment)
	t.Run("should return error for invalid comments", testParseInvalidComments)
	t.Run("should handle different timezone formats", testParseTimezoneFormats)
	t.Run("should parse all gain levels", testParseAllGainLevels)
	t.Run("should handle negative temperatures", testParseNegativeTemp)
	t.Run("should fallback to legacy parsing", testParseLegacyFallback)
}
func testParseStructuredComment(t *testing.T) {
	comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C."
	result, err := ParseAudioMothComment(comment)
	if err != nil {
		t.Fatalf("Failed to parse comment: %v", err)
	}
	expected := time.Date(2025, 2, 24, 21, 0, 0, 0, time.FixedZone("UTC+13", 13*3600))
	if !result.Timestamp.Equal(expected) {
		t.Errorf("Timestamp incorrect: got %v, want %v", result.Timestamp, expected)
	}
	utc := result.Timestamp.UTC()
	expectedUTC := time.Date(2025, 2, 24, 8, 0, 0, 0, time.UTC)
	if !utc.Equal(expectedUTC) {
		t.Errorf("UTC timestamp incorrect: got %v, want %v", utc, expectedUTC)
	}
	if result.RecorderID != "248AB50153AB0549" {
		t.Errorf("RecorderID incorrect: got %s, want 248AB50153AB0549", result.RecorderID)
	}
	}
	if result.BatteryV != 4.3 {
		t.Errorf("BatteryV incorrect: got %f, want 4.3", result.BatteryV)
	}
	if result.TempC != 15.8 {
		t.Errorf("TempC incorrect: got %f, want 15.8", result.TempC)
	}
}
func testParseInvalidComments(t *testing.T) {
	invalidComments := []string{
		"Not an AudioMoth comment",
		"Recorded at invalid time format",
		"Short comment",
		"",
		"AudioMoth without proper format",
	}
	for _, comment := range invalidComments {
		_, err := ParseAudioMothComment(comment)
		if err == nil {
			t.Errorf("Expected error for invalid comment: %s", comment)
		}
	}
}
func testParseTimezoneFormats(t *testing.T) {
	commentUTCMinus := "Recorded at 10:30:45 15/06/2024 (UTC-5) by AudioMoth 123456789ABCDEF0 at high gain while battery was 3.9V and temperature was 22.1C."
	result, err := ParseAudioMothComment(commentUTCMinus)
	if err != nil {
		t.Fatalf("Failed to parse comment: %v", err)
	}
	expected := time.Date(2024, 6, 15, 10, 30, 45, 0, time.FixedZone("UTC-5", -5*3600))
	if !result.Timestamp.Equal(expected) {
		t.Errorf("Timestamp incorrect: got %v, want %v", result.Timestamp, expected)
	}
	}
	if result.BatteryV != 3.9 {
		t.Errorf("BatteryV incorrect: got %f, want 3.9", result.BatteryV)
	}
	if result.TempC != 22.1 {
		t.Errorf("TempC incorrect: got %f, want 22.1", result.TempC)
	}
}
func testParseAllGainLevels(t *testing.T) {
	testCases := []struct {
		gainStr  string
	}{
	}
	for _, tc := range testCases {
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at " + tc.gainStr + " gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		if err != nil {
			t.Errorf("Failed to parse comment with gain %s: %v", tc.gainStr, err)
			continue
		}
		if result.Gain != tc.expected {
			t.Errorf("Gain incorrect for %s: got %s, want %s", tc.gainStr, result.Gain, tc.expected)
		}
	}
}
func testParseNegativeTemp(t *testing.T) {
	comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was -5.2C."
	result, err := ParseAudioMothComment(comment)
	if err != nil {
		t.Fatalf("Failed to parse comment: %v", err)
	}
	if result.TempC != -5.2 {
		t.Errorf("TempC incorrect: got %f, want -5.2", result.TempC)
	}
}
func testParseLegacyFallback(t *testing.T) {
	comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C"
	result, err := ParseAudioMothComment(comment)
	if err == nil {
		if result.RecorderID == "" {
			t.Error("RecorderID should not be empty")
		}
	}
}
func TestParseGainLevel(t *testing.T) {
	testCases := []struct {
		input    string
		wantErr  bool
	}{
		{"invalid", "", true},
		{"", "", true},
		{"ultra", "", true},
	}
	for _, tc := range testCases {
		t.Run(tc.input, func(t *testing.T) {
			result, err := parseGainLevel(tc.input)
			if tc.wantErr {
				if err == nil {
					t.Errorf("Expected error for input %q, got nil", tc.input)
				}
			} else {
				if err != nil {
					t.Errorf("Unexpected error for input %q: %v", tc.input, err)
				}
				if result != tc.expected {
					t.Errorf("Result incorrect for %q: got %s, want %s", tc.input, result, tc.expected)
				}
			}
		})
	}
}
func TestParseAudioMothTimestamp(t *testing.T) {
	t.Run("should parse standard timestamp format", func(t *testing.T) {
		result, err := parseAudioMothTimestamp("21:00:00", "24/02/2025", "UTC+13")
		if err != nil {
			t.Fatalf("Failed to parse timestamp: %v", err)
		}
		expected := time.Date(2025, 2, 24, 21, 0, 0, 0, time.FixedZone("UTC+13", 13*3600))
		if !result.Equal(expected) {
			t.Errorf("Timestamp incorrect: got %v, want %v", result, expected)
		}
	})
	t.Run("should parse timestamp with +HH format", func(t *testing.T) {
		result, err := parseAudioMothTimestamp("10:30:45", "15/06/2024", "+13")
		if err != nil {
			t.Fatalf("Failed to parse timestamp: %v", err)
		}
		expected := time.Date(2024, 6, 15, 10, 30, 45, 0, time.FixedZone("UTC+13", 13*3600))
		if !result.Equal(expected) {
			t.Errorf("Timestamp incorrect: got %v, want %v", result, expected)
		}
	})
	t.Run("should parse negative timezone offset", func(t *testing.T) {
		result, err := parseAudioMothTimestamp("10:30:45", "15/06/2024", "UTC-5")
		if err != nil {
			t.Fatalf("Failed to parse timestamp: %v", err)
		}
		expected := time.Date(2024, 6, 15, 10, 30, 45, 0, time.FixedZone("UTC-5", -5*3600))
		if !result.Equal(expected) {
			t.Errorf("Timestamp incorrect: got %v, want %v", result, expected)
		}
	})
	t.Run("should handle invalid time format", func(t *testing.T) {
		_, err := parseAudioMothTimestamp("25:00:00", "15/06/2024", "UTC+13")
		// Note: Go's time.Date will normalize invalid times, so this might not error
		// The error would be caught if the format doesn't match
		_ = err
	})
	t.Run("should handle invalid date format", func(t *testing.T) {
		_, err := parseAudioMothTimestamp("10:30:45", "32/13/2024", "UTC+13")
		// Note: Go's time.Date will normalize invalid dates
		_ = err
	})
}
func TestStructuredVsLegacyParsing(t *testing.T) {
	t.Run("should prefer structured parsing", func(t *testing.T) {
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		if err != nil {
			t.Fatalf("Failed to parse comment: %v", err)
		}
		// Verify it parsed correctly
		if result.RecorderID != "248AB50153AB0549" {
			t.Errorf("RecorderID incorrect: got %s, want 248AB50153AB0549", result.RecorderID)
		}
	})
	t.Run("should handle legacy format", func(t *testing.T) {
		// Create a comment that matches legacy space-separated format
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C."
		// The structured parser should handle this
		result, err := ParseAudioMothComment(comment)
		if err != nil {
			// If structured fails, legacy should catch it
			// (though for this format, structured should work)
			t.Logf("Note: Structured parsing failed, expected legacy to handle: %v", err)
		} else {
			if result.RecorderID == "" {
				t.Error("RecorderID should not be empty")
			}
		}
	})
}
func TestAudioMothCommentEdgeCases(t *testing.T) {
	t.Run("should handle extra whitespace", func(t *testing.T) {
		comment := "Recorded at  21:00:00  24/02/2025  (UTC+13)  by  AudioMoth  248AB50153AB0549  at  medium  gain  while  battery  was  4.3V  and  temperature  was  15.8C."
		// Depending on implementation, this might or might not parse
		_, err := ParseAudioMothComment(comment)
		if err != nil {
			// Expected - structured regex is strict
			t.Logf("Extra whitespace causes parsing to fail (expected): %v", err)
		}
	})
	t.Run("should handle different case in gain", func(t *testing.T) {
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at MEDIUM gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		if err == nil {
			}
		}
	})
	t.Run("should handle non-hex recorder ID via legacy parser", func(t *testing.T) {
		// Structured regex expects [A-F0-9]+ hex format and will not match
		// Legacy parser will catch this and parse it (more lenient)
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth GGGGGGGGGGGGGGGG at medium gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		// Legacy parser is lenient and accepts any recorder ID
		if err != nil {
			t.Fatalf("Legacy parser should handle non-hex recorder ID: %v", err)
		}
		// Verify it parsed the recorder ID (even though it's not valid hex)
		if result.RecorderID != "GGGGGGGGGGGGGGGG" {
			t.Errorf("RecorderID incorrect: got %s, want GGGGGGGGGGGGGGGG", result.RecorderID)
		}
	})
	t.Run("should handle recorder ID of different lengths", func(t *testing.T) {
		// Short ID
		comment := "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth ABCD at medium gain while battery was 4.3V and temperature was 15.8C."
		result, err := ParseAudioMothComment(comment)
		if err != nil {
			t.Fatalf("Failed to parse comment with short ID: %v", err)
		}
		if !strings.Contains(result.RecorderID, "ABCD") {
			t.Errorf("RecorderID should contain ABCD, got %s", result.RecorderID)
		}
	})
}
			if result.Gain != GainMedium {
				t.Errorf("Gain should be normalized: got %s, want %s", result.Gain, GainMedium)
		{"low", GainLow, false},
		{"LOW", GainLow, false},
		{"  low  ", GainLow, false},
		{"low-medium", GainLowMedium, false},
		{"medium", GainMedium, false},
		{"medium-high", GainMediumHigh, false},
		{"high", GainHigh, false},
		expected GainLevel
		{"low", GainLow},
		{"low-medium", GainLowMedium},
		{"medium", GainMedium},
		{"medium-high", GainMediumHigh},
		{"high", GainHigh},
		expected GainLevel
	if result.Gain != GainHigh {
		t.Errorf("Gain incorrect: got %s, want %s", result.Gain, GainHigh)
	if result.Gain != GainMedium {
		t.Errorf("Gain incorrect: got %s, want %s", result.Gain, GainMedium)

File deletion: audiomoth_parser.go

BF:BFD[5.1] → [5.213840:213883]

BF:BFD[5.213883] → [5.206887:206887]

B:BD[5.206887] → [5.206888:206959]

∅:D[19.4818] → [5.206959:206960]

B:BD[5.206959] → [5.206959:206960]

∅:D[19.5055] → [5.206973:207112]

B:BD[5.206973] → [5.206973:207112]

∅:D[19.5078] → [5.207137:207855]

B:BD[5.207137] → [5.207137:207855]

B:BD[5.207855] → [20.986:1091]

∅:D[20.1091] → [5.208003:208140]

B:BD[5.208003] → [5.208003:208140]

B:BD[5.208140] → [20.1092:1195]

∅:D[20.1195] → [5.208355:210046]

B:BD[5.208355] → [5.208355:210046]

B:BD[5.210046] → [20.1196:1275]

∅:D[20.1275] → [5.210124:213405]

B:BD[5.210124] → [5.210124:213405]

∅:D[19.5136] → [5.213465:213552]

B:BD[5.213465] → [5.213465:213552]

∅:D[19.5159] → [5.213577:213597]

B:BD[5.213577] → [5.213577:213597]

∅:D[19.5188] → [5.213628:213644]

B:BD[5.213628] → [5.213628:213644]

∅:D[19.5214] → [5.213672:213693]

B:BD[5.213672] → [5.213672:213693]

∅:D[19.5244] → [5.213725:213739]

B:BD[5.213725] → [5.213725:213739]

∅:D[19.5268] → [5.213765:213839]

B:BD[5.213765] → [5.213765:213839]

B:BD[5.213739] → [19.5245:5268]

B:BD[5.213693] → [19.5215:5244]

B:BD[5.213644] → [19.5189:5214]

B:BD[5.213597] → [19.5160:5188]

B:BD[5.213552] → [19.5137:5159]

B:BD[5.213405] → [19.5079:5136]

B:BD[5.207112] → [19.5056:5078]

B:BD[5.206960] → [19.4819:5055]

B:BD[5.206959] → [19.4724:4818]

package utils
import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
	"time"
)
// AudioMothData contains parsed data from AudioMoth comment field
type AudioMothData struct {
	Timestamp  time.Time
	RecorderID string
	BatteryV   float64
	TempC      float64
}
// AudioMoth comment example:
// "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C."
var (
	// Pattern to detect AudioMoth comments
	audiomothPattern = regexp.MustCompile(`(?i)AudioMoth`)
	// Pattern to extract structured data
	// Matches: "Recorded at HH:MM:SS DD/MM/YYYY (UTC±HH) by AudioMoth HEXID at GAIN gain while battery was X.XV and temperature was Y.YC."
	structuredPattern = regexp.MustCompile(
		`Recorded at (\d{2}:\d{2}:\d{2}) (\d{2}/\d{2}/\d{4}) \(UTC([+-]\d+)\) by AudioMoth ([A-F0-9]+) at ([\w-]+) gain while battery was ([\d.]+)V and temperature was ([-\d.]+)C`,
	)
)
// IsAudioMoth detects if a WAV file is from an AudioMoth recorder by checking comment and artist fields
func IsAudioMoth(comment, artist string) bool {
	return audiomothPattern.MatchString(comment) || audiomothPattern.MatchString(artist)
}
// ParseAudioMothComment extracts timestamp, gain, battery, and temperature from an AudioMoth comment.
func ParseAudioMothComment(comment string) (*AudioMothData, error) {
	// Try structured parsing first (newer format)
	if data, err := parseStructuredComment(comment); err == nil {
		return data, nil
	}
	// Fallback to legacy space-separated parsing
	return parseLegacyComment(comment)
}
// parseStructuredComment parses newer AudioMoth comment format using regex
func parseStructuredComment(comment string) (*AudioMothData, error) {
	matches := structuredPattern.FindStringSubmatch(comment)
	if matches == nil {
		return nil, fmt.Errorf("comment does not match structured AudioMoth format")
	}
	// Extract matched groups
	timeStr := matches[1]     // HH:MM:SS
	dateStr := matches[2]     // DD/MM/YYYY
	timezoneStr := matches[3] // ±HH
	recorderID := matches[4]  // Hex ID
	gainStr := matches[5]     // gain level
	batteryStr := matches[6]  // battery voltage
	tempStr := matches[7]     // temperature
	// Parse timestamp
	timestamp, err := parseAudioMothTimestamp(timeStr, dateStr, timezoneStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse timestamp: %w", err)
	}
	// Parse gain
	gain, err := parseGainLevel(gainStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse gain: %w", err)
	}
	// Parse battery voltage
	batteryV, err := strconv.ParseFloat(batteryStr, 64)
	if err != nil {
		return nil, fmt.Errorf("failed to parse battery voltage: %w", err)
	}
	// Parse temperature
	tempC, err := strconv.ParseFloat(tempStr, 64)
	if err != nil {
		return nil, fmt.Errorf("failed to parse temperature: %w", err)
	}
	return &AudioMothData{
		Timestamp:  timestamp,
		RecorderID: recorderID,
		Gain:       gain,
		BatteryV:   batteryV,
		TempC:      tempC,
	}, nil
}
// parseLegacyComment parses older AudioMoth comment format (space-separated).
// Example: "Recorded at 21:00:00 24/02/2025 (UTC+13) by AudioMoth 248AB50153AB0549 at medium gain while battery was 4.3V and temperature was 15.8C."
func parseLegacyComment(comment string) (*AudioMothData, error) {
	parts := strings.Fields(comment)
	if len(parts) < 10 {
		return nil, fmt.Errorf("comment has insufficient parts (got %d, need at least 10)", len(parts))
	}
	// 0-based indices after split by space:
	// parts[2] = "21:00:00" (time HH:MM:SS)
	// parts[3] = "24/02/2025" (date DD/MM/YYYY)
	// parts[4] = "(UTC+13)" (timezone offset)
	// parts[7] = "248AB50153AB0549" (moth ID)
	// parts[9] = "medium" (gain)
	// parts[len-5] = "4.3V" (battery voltage)
	// parts[len-1] = "15.8C." (temperature)
	timeStr := parts[2]
	dateStr := parts[3]
	timezoneStr := strings.Trim(parts[4], "()")
	recorderID := parts[7]
	gainStr := parts[9]
	// Parse timestamp
	timestamp, err := parseAudioMothTimestamp(timeStr, dateStr, timezoneStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse timestamp: %w", err)
	}
	// Parse gain
	gain, err := parseGainLevel(gainStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse gain: %w", err)
	}
	// Parse battery voltage (e.g., "4.3V")
	batteryStr := parts[len(parts)-5]
	batteryStr = strings.TrimSuffix(batteryStr, "V")
	batteryV, err := strconv.ParseFloat(batteryStr, 64)
	if err != nil {
		return nil, fmt.Errorf("failed to parse battery voltage: %w", err)
	}
	// Parse temperature (e.g., "15.8C." or "15.8C")
	tempStr := parts[len(parts)-1]
	tempStr = strings.TrimSuffix(tempStr, ".")
	tempStr = strings.TrimSuffix(tempStr, "C")
	tempC, err := strconv.ParseFloat(tempStr, 64)
	if err != nil {
		return nil, fmt.Errorf("failed to parse temperature: %w", err)
	}
	return &AudioMothData{
		Timestamp:  timestamp,
		RecorderID: recorderID,
		Gain:       gain,
		BatteryV:   batteryV,
		TempC:      tempC,
	}, nil
}
// parseAudioMothTimestamp parses AudioMoth timestamp from time, date, and timezone strings
// timeStr: "HH:MM:SS"
// dateStr: "DD/MM/YYYY"
// timezoneStr: "UTC+13" or "+13"
func parseAudioMothTimestamp(timeStr, dateStr, timezoneStr string) (time.Time, error) {
	// Parse time components
	timeParts := strings.Split(timeStr, ":")
	if len(timeParts) != 3 {
		return time.Time{}, fmt.Errorf("invalid time format: %s", timeStr)
	}
	hour, _ := strconv.Atoi(timeParts[0])
	minute, _ := strconv.Atoi(timeParts[1])
	second, _ := strconv.Atoi(timeParts[2])
	// Parse date components
	dateParts := strings.Split(dateStr, "/")
	if len(dateParts) != 3 {
		return time.Time{}, fmt.Errorf("invalid date format: %s", dateStr)
	}
	day, _ := strconv.Atoi(dateParts[0])
	month, _ := strconv.Atoi(dateParts[1])
	year, _ := strconv.Atoi(dateParts[2])
	// Parse timezone offset
	timezoneStr = strings.TrimPrefix(timezoneStr, "UTC")
	offsetHours, err := strconv.Atoi(timezoneStr)
	if err != nil {
		return time.Time{}, fmt.Errorf("invalid timezone offset: %s", timezoneStr)
	}
	// Create fixed timezone location
	offsetSeconds := offsetHours * 3600
	loc := time.FixedZone(fmt.Sprintf("UTC%+d", offsetHours), offsetSeconds)
	// Construct timestamp
	timestamp := time.Date(year, time.Month(month), day, hour, minute, second, 0, loc)
	return timestamp, nil
}
// parseGainLevel converts string gain level to GainLevel enum
	gainStr = strings.ToLower(strings.TrimSpace(gainStr))
	switch gainStr {
	case "low":
	case "low-medium":
	case "medium":
	case "medium-high":
	case "high":
	default:
		return "", fmt.Errorf("unknown gain level: %s", gainStr)
	}
}
		return GainHigh, nil
		return GainMediumHigh, nil
		return GainMedium, nil
		return GainLowMedium, nil
		return GainLow, nil
func parseGainLevel(gainStr string) (GainLevel, error) {
	Gain       GainLevel
// AudioMoth gain level enum constants
const (
	GainLow        GainLevel = "low"
	GainLowMedium  GainLevel = "low-medium"
	GainMedium     GainLevel = "medium"
	GainMediumHigh GainLevel = "medium-high"
	GainHigh       GainLevel = "high"
)
// GainLevel represents the gain_level enum for AudioMoth recordings
type GainLevel string

Insertion in utils/spectrogram.go at line 14 [5.62723]
[3.24873]
[5.62826]
```
	"skraak/wav"
```

Replacement in utils/spectrogram.go at line 229 [5.62723]

B:BD[15.4710] → [15.4710:4793]

	segSamples, sampleRate, err := ReadWAVSegmentSamples(wavPath, startTime, endTime)

[15.4710]

[5.68207]

	segSamples, sampleRate, err := wav.ReadWAVSegmentSamples(wavPath, startTime, endTime)

Insertion in utils/file_import_test.go at line 7 [5.130911]
[5.130955]
[5.130955]
```
	"skraak/wav"
```

Replacement in utils/file_import_test.go at line 56 [5.130911]

B:BD[10.2664] → [10.2664:2802]

func mustResolveTimestamp(t *testing.T, meta *WAVMetadata, filename, tz string, useModTime bool, preParsed *time.Time) *TimestampResult {

[10.2664]

[10.2802]

func mustResolveTimestamp(t *testing.T, meta *wav.WAVMetadata, filename, tz string, useModTime bool, preParsed *time.Time) *TimestampResult {

Replacement in utils/file_import_test.go at line 67 [5.130911]
B:BD[5.132057] → [5.132057:132081]
```
		meta := &WAVMetadata{
```
[5.132057]
[5.132081]
```
		meta := &wav.WAVMetadata{
```

Replacement in utils/file_import_test.go at line 85 [5.130911]

B:BD[5.132892] → [10.3064:3171]

		result := mustResolveTimestamp(t, &WAVMetadata{}, "20250224_210000.wav", "Pacific/Auckland", false, nil)

[5.132892]

[5.133105]

		result := mustResolveTimestamp(t, &wav.WAVMetadata{}, "20250224_210000.wav", "Pacific/Auckland", false, nil)

Replacement in utils/file_import_test.go at line 96 [5.130911]
B:BD[5.133398] → [10.3172:3217]
```
		meta := &WAVMetadata{FileModTime: modTime}
```
[5.133398]
[10.3217]
```
		meta := &wav.WAVMetadata{FileModTime: modTime}
```

Replacement in utils/file_import_test.go at line 113 [5.130911]

B:BD[10.3562] → [10.3562:3666]

				_, err := ResolveTimestamp(&WAVMetadata{}, "nopattern.wav", "Pacific/Auckland", tc.useModTime, nil)

[10.3562]

[10.3666]

				_, err := ResolveTimestamp(&wav.WAVMetadata{}, "nopattern.wav", "Pacific/Auckland", tc.useModTime, nil)

Replacement in utils/file_import_test.go at line 122 [5.130911]

B:BD[5.134472] → [10.3758:3816]

		meta := &WAVMetadata{Comment: "AudioMoth garbage data"}

[5.134472]

[10.3816]

		meta := &wav.WAVMetadata{Comment: "AudioMoth garbage data"}

Replacement in utils/file_import_test.go at line 140 [5.130911]

B:BD[6.9087] → [6.9087:9154]

	err := WriteWAVFile(tmpPath, []float64{0.1, 0.2, 0.3, 0.4}, 8000)

[6.9087]

[6.9154]

	err := wav.WriteWAVFile(tmpPath, []float64{0.1, 0.2, 0.3, 0.4}, 8000)

Replacement in utils/file_import_test.go at line 145 [5.130911]

B:BD[6.9224] → [6.9224:9486]

	// Test 1: Read specific segment (0.25s = 2 samples at 8000Hz)
	// Actually, 1 sample is 1/8000s. Let's just read the whole thing for the test to keep it simple and test the binary chunk reading logic
	samples, rate, err := ReadWAVSegmentSamples(tmpPath, 0, 0)

[6.9224]

[6.9486]

	// Read specific segment
	samples, rate, err := wav.ReadWAVSegmentSamples(tmpPath, 0, 0)

Replacement in utils/file_import_test.go at line 157 [5.130911]

B:BD[6.9705] → [6.9705:9792]

	// Test 2: Helper ReadWAVSamples wrapper
	samples2, _, err := ReadWAVSamples(tmpPath)

[6.9705]

[6.9792]

	// Helper ReadWAVSamples wrapper
	samples2, _, err := wav.ReadWAVSamples(tmpPath)

Replacement in utils/file_import_test.go at line 169 [5.130911]

B:BD[6.10044] → [6.10044:10101]

	err := WriteWAVFile(tmpPath, []float64{0.0, 0.0}, 8000)

[6.10044]

[6.10101]

	err := wav.WriteWAVFile(tmpPath, []float64{0.0, 0.0}, 8000)

Replacement in utils/file_import_test.go at line 189 [5.130911]

B:BD[6.10576] → [6.10576:10633]

	err := WriteWAVFile(tmpPath, []float64{0.0, 0.0}, 8000)

[6.10576]

[6.10633]

	err := wav.WriteWAVFile(tmpPath, []float64{0.0, 0.0}, 8000)

Replacement in utils/file_import_test.go at line 194 [5.130911]
B:BD[6.10703] → [6.10703:10755]
```
	meta, hash, err := ParseWAVHeaderWithHash(tmpPath)
```
[6.10703]
[6.10755]
```
	meta, hash, err := wav.ParseWAVHeaderWithHash(tmpPath)
```
Insertion in utils/file_import.go at line 7 [5.135067]
[5.135140]
[5.135140]
```
	"skraak/wav"
```
Replacement in utils/file_import.go at line 15 [5.135067]
B:BD[5.135292] → [5.135292:135320]
```
	MothData    *AudioMothData
```
[5.135292]
[5.135320]
```
	MothData    *wav.AudioMothData
```

Replacement in utils/file_import.go at line 24 [5.135067]

B:BD[5.135606] → [6.10962:11125]

func ResolveTimestamp(wavMeta *WAVMetadata, filePath string, timezoneID string, useFileModTime bool, preParsedFilenameTime *time.Time) (*TimestampResult, error) {

[5.135606]

[5.135735]

func ResolveTimestamp(wavMeta *wav.WAVMetadata, filePath string, timezoneID string, useFileModTime bool, preParsedFilenameTime *time.Time) (*TimestampResult, error) {

Replacement in utils/file_import.go at line 28 [5.135067]
B:BD[5.135800] → [5.135800:135851]
```
	if IsAudioMoth(wavMeta.Comment, wavMeta.Artist) {
```
[5.135800]
[5.135851]
```
	if wav.IsAudioMoth(wavMeta.Comment, wavMeta.Artist) {
```

Replacement in utils/file_import.go at line 30 [5.135067]

B:BD[5.135879] → [5.135879:135937]

		mothData, err := ParseAudioMothComment(wavMeta.Comment)

[5.135879]

[5.135937]

		mothData, err := wav.ParseAudioMothComment(wavMeta.Comment)

Replacement in utils/file_import.go at line 71 [5.135067]
B:BD[5.137052] → [5.137052:137083]
```
	MothData       *AudioMothData
```
[5.137052]
[5.137083]
```
	MothData       *wav.AudioMothData
```
Replacement in utils/file_import.go at line 81 [5.135067]
B:BD[5.137532] → [5.137532:137575]
```
	metadata, err := ParseWAVHeader(filePath)
```
[5.137532]
[5.137575]
```
	metadata, err := wav.ParseWAVHeader(filePath)
```
Insertion in tui/update.go at line 15 [22.3875]
[21.6322]
[22.3972]
```
	"skraak/wav"
```

Replacement in tui/update.go at line 454 [22.3875]

B:BD[21.8672] → [21.8672:8767]

		samples, sampleRate, err := utils.ReadWAVSegmentSamples(wavPath, seg.StartTime, seg.EndTime)

[21.8672]

[21.8767]

		samples, sampleRate, err := wav.ReadWAVSegmentSamples(wavPath, seg.StartTime, seg.EndTime)

Insertion in tools/import/import_unstructured.go at line 15 [23.21]
[23.159]
[23.159]
```
	"skraak/wav"
```
Replacement in tools/import/import_unstructured.go at line 111 [23.21]
B:BD[23.3261] → [23.3261:3310]
```
	metadata, err := utils.ParseWAVHeader(filePath)
```
[23.3261]
[23.3310]
```
	metadata, err := wav.ParseWAVHeader(filePath)
```
Insertion in tools/import/cluster_import.go at line 12 [24.17845]
[24.17950]
[24.17950]
```
	"skraak/wav"
```
Replacement in tools/import/cluster_import.go at line 217 [24.17845]
B:BD[24.24156] → [24.24156:24185]
```
	metadata *utils.WAVMetadata
```
[24.24156]
[24.24185]
```
	metadata *wav.WAVMetadata
```
Replacement in tools/import/cluster_import.go at line 297 [24.17845]
B:BD[24.26709] → [24.26709:26769]
```
		metadata, hash, err := utils.ParseWAVHeaderWithHash(path)
```
[24.26709]
[24.26769]
```
		metadata, hash, err := wav.ParseWAVHeaderWithHash(path)
```
Insertion in tools/calls/isnight.go at line 11 [23.69713]
[23.69815]
[23.69815]
```
	"skraak/wav"
```
Replacement in tools/calls/isnight.go at line 50 [23.69713]
B:BD[23.71208] → [23.71208:71263]
```
	metadata, err := utils.ParseWAVHeader(input.FilePath)
```
[23.71208]
[23.71263]
```
	metadata, err := wav.ParseWAVHeader(input.FilePath)
```
Replacement in tools/calls/calls_from_raven.go at line 11 [23.143341]
B:BD[23.143428] → [23.143428:143444]
```
	"skraak/utils"
```
[23.143428]
[23.143444]
```
	"skraak/wav"
```

Replacement in tools/calls/calls_from_raven.go at line 229 [23.143341]

B:BD[23.150032] → [23.150032:150099]

	sampleRate, duration, err := utils.ParseWAVHeaderMinimal(wavPath)

[23.150032]

[23.150099]

	sampleRate, duration, err := wav.ParseWAVHeaderMinimal(wavPath)

Insertion in tools/calls/calls_from_preds.go at line 17 [23.163566]
[23.163730]
[23.163730]
```
	"skraak/wav"
```

Replacement in tools/calls/calls_from_preds.go at line 421 [23.163566]

B:BD[23.176596] → [23.176596:176664]

		sampleRate, duration, err := utils.ParseWAVHeaderMinimal(wavPath)

[23.176596]

[23.176664]

		sampleRate, duration, err := wav.ParseWAVHeaderMinimal(wavPath)

Replacement in tools/calls/calls_from_preds.go at line 516 [23.163566]

B:BD[23.179007] → [23.179007:179075]

		sampleRate, duration, err := utils.ParseWAVHeaderMinimal(wavPath)

[23.179007]

[23.179075]

		sampleRate, duration, err := wav.ParseWAVHeaderMinimal(wavPath)

Replacement in tools/calls/calls_from_birda.go at line 12 [23.203841]
B:BD[23.203941] → [23.203941:203957]
```
	"skraak/utils"
```
[23.203941]
[23.203957]
```
	"skraak/wav"
```

Replacement in tools/calls/calls_from_birda.go at line 221 [23.203841]

B:BD[23.210200] → [23.210200:210267]

	sampleRate, duration, err := utils.ParseWAVHeaderMinimal(wavPath)

[23.210200]

[23.210267]

	sampleRate, duration, err := wav.ParseWAVHeaderMinimal(wavPath)

Insertion in tools/calls/calls_clip_bench_test.go at line 11 [23.248071]
[23.248157]
[23.248157]
```
	"skraak/wav"
```
Replacement in tools/calls/calls_clip_bench_test.go at line 21 [23.248071]
B:BD[23.248350] → [23.248350:248396]
```
		_, _, err := utils.ReadWAVSamples(benchWAV)
```
[23.248350]
[23.248396]
```
		_, _, err := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 57 [23.248071]
B:BD[23.249368] → [23.249368:249418]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.249368]
[23.249418]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 64 [23.248071]
B:BD[23.249636] → [23.249636:249683]
```
		utils.WriteWAVFile(f.Name(), segSamples, sr)
```
[23.249636]
[23.249683]
```
		wav.WriteWAVFile(f.Name(), segSamples, sr)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 73 [23.248071]
B:BD[23.249825] → [23.249825:249874]
```
	samples, _, _ := utils.ReadWAVSamples(benchWAV)
```
[23.249825]
[23.249874]
```
	samples, _, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 83 [23.248071]
B:BD[23.250094] → [23.250094:250143]
```
	samples, _, _ := utils.ReadWAVSamples(benchWAV)
```
[23.250094]
[23.250143]
```
	samples, _, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 95 [23.248071]
B:BD[23.250429] → [23.250429:250479]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.250429]
[23.250479]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 109 [23.248071]
B:BD[23.250779] → [23.250779:250829]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.250779]
[23.250829]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 126 [23.248071]
B:BD[23.251326] → [23.251326:251376]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.251326]
[23.251376]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 141 [23.248071]
B:BD[23.251813] → [23.251813:251863]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.251813]
[23.251863]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 158 [23.248071]
B:BD[23.252320] → [23.252320:252370]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.252320]
[23.252370]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 173 [23.248071]
B:BD[23.252737] → [23.252737:252787]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.252737]
[23.252787]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 189 [23.248071]
B:BD[23.253197] → [23.253197:253247]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.253197]
[23.253247]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 204 [23.248071]
B:BD[23.253623] → [23.253623:253673]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.253623]
[23.253673]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 220 [23.248071]
B:BD[23.254089] → [23.254089:254139]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.254089]
[23.254139]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 238 [23.248071]
B:BD[23.254610] → [23.254610:254660]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.254610]
[23.254660]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 257 [23.248071]
B:BD[23.255196] → [23.255196:255246]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.255196]
[23.255246]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 275 [23.248071]
B:BD[23.255791] → [23.255791:255844]
```
		utils.WriteWAVFile(f.Name(), segSamples, outputSR)
```
[23.255791]
[23.255844]
```
		wav.WriteWAVFile(f.Name(), segSamples, outputSR)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 282 [23.248071]
B:BD[23.255937] → [23.255937:255987]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.255937]
[23.255987]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 301 [23.248071]
B:BD[23.256574] → [23.256574:256627]
```
		utils.WriteWAVFile(f.Name(), segSamples, outputSR)
```
[23.256574]
[23.256627]
```
		wav.WriteWAVFile(f.Name(), segSamples, outputSR)
```
Replacement in tools/calls/calls_clip_bench_test.go at line 310 [23.248071]
B:BD[23.256781] → [23.256781:256831]
```
	samples, sr, _ := utils.ReadWAVSamples(benchWAV)
```
[23.256781]
[23.256831]
```
	samples, sr, _ := wav.ReadWAVSamples(benchWAV)
```
Insertion in tools/calls/calls_clip.go at line 13 [23.257886]
[23.258005]
[23.258005]
```
	"skraak/wav"
```
Replacement in tools/calls/calls_clip.go at line 221 [23.257886]
B:BD[23.264914] → [23.264914:264973]
```
	samples, sampleRate, err := utils.ReadWAVSamples(wavPath)
```
[23.264914]
[23.264973]
```
	samples, sampleRate, err := wav.ReadWAVSamples(wavPath)
```

Replacement in tools/calls/calls_clip.go at line 367 [23.257886]

B:BD[23.270780] → [21.9814:9891]

	if err := utils.WriteWAVFile(wavPath, segSamples, sampleRate); err != nil {

[23.270780]

[23.270863]

	if err := wav.WriteWAVFile(wavPath, segSamples, sampleRate); err != nil {

Insertion in tools/calls/calls_classify.go at line 15 [23.292067]
[23.292189]
[23.292189]
```
	"skraak/wav"
```

Replacement in tools/calls/calls_classify.go at line 714 [23.292067]

B:BD[21.10272] → [21.10272:10369]

	segSamples, sampleRate, err := utils.ReadWAVSegmentSamples(wavPath, seg.StartTime, seg.EndTime)

[21.10272]

[21.10369]

	segSamples, sampleRate, err := wav.ReadWAVSegmentSamples(wavPath, seg.StartTime, seg.EndTime)

Replacement in tools/calls/calls_classify.go at line 765 [23.292067]

B:BD[21.11999] → [21.11999:12076]

	if err := utils.WriteWAVFile(wavPath, segSamples, sampleRate); err != nil {

[21.11999]

[21.12076]

	if err := wav.WriteWAVFile(wavPath, segSamples, sampleRate); err != nil {

Insertion in tools/calls/calls_add.go at line 9 [25.27602]
[25.27668]
[25.27668]
```
	"skraak/wav"
```

Replacement in tools/calls/calls_add.go at line 142 [25.27602]

B:BD[25.31838] → [25.31838:31898]

	sampleRate, _, err := utils.ParseWAVHeaderMinimal(wavPath)

[25.31838]

[25.31898]

	sampleRate, _, err := wav.ParseWAVHeaderMinimal(wavPath)

Replacement in tools/calls/calls_add.go at line 165 [25.27602]
B:BD[25.32277] → [25.32277:32335]
```
	_, duration, err := utils.ParseWAVHeaderMinimal(wavPath)
```
[25.32277]
[25.32335]
```
	_, duration, err := wav.ParseWAVHeaderMinimal(wavPath)
```
Replacement in db/types.go at line 7 [5.790937]
B:BD[19.6300] → [19.6300:6316]
```
	"skraak/utils"
```
[19.6300]
[5.790984]
```
	"skraak/wav"
```
Replacement in db/types.go at line 198 [5.790937]
B:BD[19.6384] → [19.6384:6417]
```
type GainLevel = utils.GainLevel
```
[19.6384]
[5.797780]
```
type GainLevel = wav.GainLevel
```
Replacement in db/types.go at line 200 [5.790937]
B:BD[5.797781] → [19.6418:6466]
```
// Gain level constants re-exported from utils.
```
[5.797781]
[5.797820]
```
// Gain level constants re-exported from wav.
```

Replacement in db/types.go at line 202 [5.790937]

B:BD[5.797828] → [19.6467:6644]

	GainLow        = utils.GainLow
	GainLowMedium  = utils.GainLowMedium
	GainMedium     = utils.GainMedium
	GainMediumHigh = utils.GainMediumHigh
	GainHigh       = utils.GainHigh

[5.797828]

[5.798017]

	GainLow        = wav.GainLow
	GainLowMedium  = wav.GainLowMedium
	GainMedium     = wav.GainMedium
	GainMediumHigh = wav.GainMediumHigh
	GainHigh       = wav.GainHigh

Replacement in cmd/metadata.go at line 9 [5.1058230]
B:BD[5.1058292] → [5.1058292:1058308]
```
	"skraak/utils"
```
[5.1058292]
[5.1058308]
```
	"skraak/wav"
```
Replacement in cmd/metadata.go at line 49 [5.1058230]
B:BD[5.1059691] → [5.1059691:1059741]
```
	metadata, err := utils.ParseWAVHeader(*filePath)
```
[5.1059670]
[5.1059741]
```
	metadata, err := wav.ParseWAVHeader(*filePath)
```

Insertion in CHANGELOG.md at line 4 [5.1197933]

[5.1198010]

[3.26323]


## [2026-05-19] Extract wav/ package (Phase 3)
- **Created `wav/` package** with 3 files from `utils/`:
  - `wav_metadata.go` — `WAVMetadata`, `ParseWAVHeader`, `ParseWAVHeaderMinimal`, `ParseWAVHeaderWithHash`, `ReadWAVSegmentSamples`, `ReadWAVSamples`
  - `wav_writer.go` — `WriteWAVFile`
  - `audiomoth_parser.go` — `AudioMothData`, `GainLevel`, `ParseAudioMothComment`, `IsAudioMoth`, gain constants
- **`ResolveTimestamp` + `ProcessSingleFile` stayed in `utils/file_import.go`** — moving them to `wav/` would create an import cycle (`utils/spectrogram.go` → `wav/`), since they depend on `utils.ComputeXXH64`, `utils.HasTimestampFilename`, etc. They can move after Phase 4 extracts `spectrogram/`.
- `utils/file_import.go` updated to import `wav/` for types (`wav.WAVMetadata`, `wav.AudioMothData`, `wav.IsAudioMoth`, `wav.ParseAudioMothComment`, `wav.ParseWAVHeader`)
- `utils/wav_writer.go` imports `audio/` for `Float64ToPCM16` (was already updated in Phase 2)
- `wav/wav_metadata.go` has its own local hash buffer pool (was sharing `utils.getHashBuffer`/`putHashBuffer`)
- Updated callers: `db/types.go` (`utils.GainLevel` → `wav.GainLevel`), `cmd/metadata.go`, `tools/calls/*.go`, `tools/import/cluster_import.go`, `tools/import/import_file.go`, `tools/import/import_unstructured.go`, `tui/update.go`, `utils/spectrogram.go`
- Moved 3 test files to `wav/`; updated `utils/file_import_test.go` with `wav.` qualified calls
- `utils/` shrinks from 2,914 → 2,112 LOC (19 → 16 non-test files)

third phase of utils refactor, wav/

Dependencies

In channels

Change contents

File addition: wav (d--x------)

File addition: wav_writer_test.go (----------)

File addition: wav_writer.go (----------)

File addition: wav_metadata_test.go (----------)

File addition: wav_metadata.go (----------)

File addition: audiomoth_parser_test.go (----------)

File addition: audiomoth_parser.go (----------)

File deletion: wav_writer_test.go

File deletion: wav_writer.go

File deletion: wav_metadata_test.go

File deletion: wav_metadata.go

File deletion: audiomoth_parser_test.go

File deletion: audiomoth_parser.go

Insertion in utils/spectrogram.go at line 14 [5.62723]

Replacement in utils/spectrogram.go at line 229 [5.62723]

Insertion in utils/file_import_test.go at line 7 [5.130911]

Replacement in utils/file_import_test.go at line 56 [5.130911]

Replacement in utils/file_import_test.go at line 67 [5.130911]

Replacement in utils/file_import_test.go at line 85 [5.130911]

Replacement in utils/file_import_test.go at line 96 [5.130911]

Replacement in utils/file_import_test.go at line 113 [5.130911]

Replacement in utils/file_import_test.go at line 122 [5.130911]

Replacement in utils/file_import_test.go at line 140 [5.130911]

Replacement in utils/file_import_test.go at line 145 [5.130911]

Replacement in utils/file_import_test.go at line 157 [5.130911]

Replacement in utils/file_import_test.go at line 169 [5.130911]

Replacement in utils/file_import_test.go at line 189 [5.130911]

Replacement in utils/file_import_test.go at line 194 [5.130911]

Insertion in utils/file_import.go at line 7 [5.135067]

Replacement in utils/file_import.go at line 15 [5.135067]

Replacement in utils/file_import.go at line 24 [5.135067]

Replacement in utils/file_import.go at line 28 [5.135067]

Replacement in utils/file_import.go at line 30 [5.135067]

Replacement in utils/file_import.go at line 71 [5.135067]

Replacement in utils/file_import.go at line 81 [5.135067]

Insertion in tui/update.go at line 15 [22.3875]

Replacement in tui/update.go at line 454 [22.3875]

Insertion in tools/import/import_unstructured.go at line 15 [23.21]

Replacement in tools/import/import_unstructured.go at line 111 [23.21]

Insertion in tools/import/cluster_import.go at line 12 [24.17845]

Replacement in tools/import/cluster_import.go at line 217 [24.17845]

Replacement in tools/import/cluster_import.go at line 297 [24.17845]

Insertion in tools/calls/isnight.go at line 11 [23.69713]

Replacement in tools/calls/isnight.go at line 50 [23.69713]

Replacement in tools/calls/calls_from_raven.go at line 11 [23.143341]

Replacement in tools/calls/calls_from_raven.go at line 229 [23.143341]

Insertion in tools/calls/calls_from_preds.go at line 17 [23.163566]

Replacement in tools/calls/calls_from_preds.go at line 421 [23.163566]

Replacement in tools/calls/calls_from_preds.go at line 516 [23.163566]

Replacement in tools/calls/calls_from_birda.go at line 12 [23.203841]

Replacement in tools/calls/calls_from_birda.go at line 221 [23.203841]

Insertion in tools/calls/calls_clip_bench_test.go at line 11 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 21 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 57 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 64 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 73 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 83 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 95 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 109 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 126 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 141 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 158 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 173 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 189 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 204 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 220 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 238 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 257 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 275 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 282 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 301 [23.248071]

Replacement in tools/calls/calls_clip_bench_test.go at line 310 [23.248071]

Insertion in tools/calls/calls_clip.go at line 13 [23.257886]

Replacement in tools/calls/calls_clip.go at line 221 [23.257886]

Replacement in tools/calls/calls_clip.go at line 367 [23.257886]

Insertion in tools/calls/calls_classify.go at line 15 [23.292067]