package utils
import (
	"os"
	"path/filepath"
	"testing"
)
func TestComputeXXH64_WAVFile(t *testing.T) {
	wavFile := filepath.Join("..", "audio", "N14-2025-02-25-20241116_054500-685-703.wav")
	hash, err := ComputeXXH64(wavFile)
	if err != nil {
		t.Fatalf("ComputeXXH64() error = %v", err)
	}
	expectedHash := "48dc1684324621de"
	if hash != expectedHash {
		t.Errorf("ComputeXXH64() = %v, want %v", hash, expectedHash)
	}
}
func TestComputeXXH64_Format(t *testing.T) {
	wavFile := filepath.Join("..", "audio", "N14-2025-02-25-20241116_054500-685-703.wav")
	hash, err := ComputeXXH64(wavFile)
	if err != nil {
		t.Fatalf("ComputeXXH64() error = %v", err)
	}
	if len(hash) != 16 {
		t.Errorf("hash length = %d, want 16", len(hash))
	}
	for _, c := range hash {
		if (c < '0' || c > '9') && (c < 'a' || c > 'f') {
			t.Errorf("invalid hex character '%c' in hash %s", c, hash)
		}
	}
}
func TestComputeXXH64_FileNotFound(t *testing.T) {
	_, err := ComputeXXH64("nonexistent-file.wav")
	if err == nil {
		t.Error("expected error for nonexistent file, got nil")
	}
}
func TestComputeXXH64_EmptyFile(t *testing.T) {
	tmpDir := t.TempDir()
	emptyFile := filepath.Join(tmpDir, "empty.wav")
	if err := createEmptyFile(emptyFile); err != nil {
		t.Fatalf("Failed to create empty file: %v", err)
	}
	hash, err := ComputeXXH64(emptyFile)
	if err != nil {
		t.Fatalf("ComputeXXH64() error = %v", err)
	}
	expectedEmpty := "ef46db3751d8e999"
	if hash != expectedEmpty {
		t.Errorf("ComputeXXH64(empty file) = %v, want %v", hash, expectedEmpty)
	}
}
func TestComputeXXH64_Deterministic(t *testing.T) {
	wavFile := filepath.Join("..", "audio", "N14-2025-02-25-20241116_054500-685-703.wav")
	hash1, err := ComputeXXH64(wavFile)
	if err != nil {
		t.Fatalf("first call error = %v", err)
	}
	hash2, err := ComputeXXH64(wavFile)
	if err != nil {
		t.Fatalf("second call error = %v", err)
	}
	hash3, err := ComputeXXH64(wavFile)
	if err != nil {
		t.Fatalf("third call error = %v", err)
	}
	if hash1 != hash2 || hash2 != hash3 {
		t.Errorf("hashes not deterministic: %s, %s, %s", hash1, hash2, hash3)
	}
}
func TestComputeXXH64_LeadingZeros(t *testing.T) {
	tmpDir := t.TempDir()
	smallFile := filepath.Join(tmpDir, "small.dat")
	if err := createSmallFile(smallFile); err != nil {
		t.Fatalf("Failed to create small file: %v", err)
	}
	hash, err := ComputeXXH64(smallFile)
	if err != nil {
		t.Fatalf("ComputeXXH64() error = %v", err)
	}
	if len(hash) != 16 {
		t.Errorf("hash length = %d, want 16 (leading zeros should be preserved)", len(hash))
	}
}
func BenchmarkComputeXXH64_Small(b *testing.B) {
	f := filepath.Join("..", "audio", "N14-2025-02-25-20241116_054500-685-703.wav") // 547K
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ComputeXXH64(f)
	}
}
func BenchmarkComputeXXH64_Medium(b *testing.B) {
	f := filepath.Join("..", "audio", "20250518_210000.WAV") // 14M
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ComputeXXH64(f)
	}
}
func BenchmarkComputeXXH64_Large(b *testing.B) {
	f := filepath.Join("..", "audio", "E166_BIRD_111211_042726.wav") // 55M
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ComputeXXH64(f)
	}
}
func createEmptyFile(path string) error {
	file, err := os.Create(path)
	if err != nil {
		return err
	}
	return file.Close()
}
func createSmallFile(path string) error {
	file, err := os.Create(path)
	if err != nil {
		return err
	}
	defer file.Close()
	_, err = file.Write([]byte{0x42})
	return err
}

package utils
import (
	"fmt"
	"io"
	"os"
	"sync"
	"github.com/cespare/xxhash/v2"
)
var hashBufferPool = sync.Pool{
	New: func() any {
		buf := make([]byte, 128*1024)
		return &buf
	},
}
func getHashBuffer() *[]byte {
	return hashBufferPool.Get().(*[]byte)
}
func putHashBuffer(buf *[]byte) {
	hashBufferPool.Put(buf)
}
// ComputeXXH64 computes the XXH64 hash of a file using streaming I/O.
// Uses a constant ~128KB buffer regardless of file size.
// Returns the hash as a 16-character lowercase hexadecimal string.
func ComputeXXH64(filepath string) (string, error) {
	file, err := os.Open(filepath)
	if err != nil {
		return "", fmt.Errorf("failed to open file: %w", err)
	}
	defer func() { _ = file.Close() }()
	hashBufPtr := getHashBuffer()
	defer putHashBuffer(hashBufPtr)
	h := xxhash.New()
	if _, err := io.CopyBuffer(h, file, *hashBufPtr); err != nil {
		return "", fmt.Errorf("failed to read file: %w", err)
	}
	return fmt.Sprintf("%016x", h.Sum64()), nil
}

package utils
import (
	"bufio"
	"encoding/binary"
	"fmt"
	"os"
)
// 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 := make([]byte, dataSize)
		for i, sample := range samples {
			// Clamp to [-1, 1]
			if sample > 1.0 {
				sample = 1.0
			} else if sample < -1.0 {
				sample = -1.0
			}
			binary.LittleEndian.PutUint16(buf[i*2:], uint16(int16(sample*32767)))
		}
		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
}

package utils
import (
	"bytes"
	"encoding/binary"
	"fmt"
	"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 TestParseWAVHeader(t *testing.T) {
	// Create temporary directory for test files
	tmpDir := t.TempDir()
	t.Run("should parse basic WAV metadata", func(t *testing.T) {
		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)
		}
		// Duration should be approximately 60 seconds (allow small rounding error)
		if metadata.Duration < 59.9 || metadata.Duration > 60.1 {
			t.Errorf("Duration incorrect: got %f, want ~60.0", metadata.Duration)
		}
	})
	t.Run("should extract comment metadata", func(t *testing.T) {
		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)
		}
	})
	t.Run("should extract artist metadata", func(t *testing.T) {
		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)
		}
	})
	t.Run("should extract both comment and artist", func(t *testing.T) {
		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)
		}
	})
	t.Run("should handle different sample rates", func(t *testing.T) {
		testCases := []struct {
			sampleRate int
		}{
			{8000},
			{16000},
			{22050},
			{44100},
			{48000},
			{96000},
		}
		for _, tc := range testCases {
			t.Run("", func(t *testing.T) {
				path := createTestWAVFile(t, tmpDir, "test_sr.wav", struct {
					duration      float64
					sampleRate    int
					channels      int
					bitsPerSample int
					comment       string
					artist        string
				}{
					duration:      1.0,
					sampleRate:    tc.sampleRate,
					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 != tc.sampleRate {
					t.Errorf("SampleRate incorrect: got %d, want %d", metadata.SampleRate, tc.sampleRate)
				}
			})
		}
	})
	t.Run("should handle different channel counts", func(t *testing.T) {
		testCases := []struct {
			channels int
		}{
			{1}, // Mono
			{2}, // Stereo
		}
		for _, tc := range testCases {
			t.Run("", func(t *testing.T) {
				path := createTestWAVFile(t, tmpDir, "test_ch.wav", struct {
					duration      float64
					sampleRate    int
					channels      int
					bitsPerSample int
					comment       string
					artist        string
				}{
					duration:      1.0,
					sampleRate:    44100,
					channels:      tc.channels,
					bitsPerSample: 16,
					comment:       "",
					artist:        "",
				})
				metadata, err := ParseWAVHeader(path)
				if err != nil {
					t.Fatalf("Failed to parse WAV header: %v", err)
				}
				if metadata.Channels != tc.channels {
					t.Errorf("Channels incorrect: got %d, want %d", metadata.Channels, tc.channels)
				}
			})
		}
	})
	t.Run("should handle different bit depths", func(t *testing.T) {
		testCases := []struct {
			bitsPerSample int
		}{
			{8},
			{16},
			{24},
			{32},
		}
		for _, tc := range testCases {
			t.Run("", func(t *testing.T) {
				path := createTestWAVFile(t, tmpDir, "test_bits.wav", struct {
					duration      float64
					sampleRate    int
					channels      int
					bitsPerSample int
					comment       string
					artist        string
				}{
					duration:      1.0,
					sampleRate:    44100,
					channels:      1,
					bitsPerSample: tc.bitsPerSample,
					comment:       "",
					artist:        "",
				})
				metadata, err := ParseWAVHeader(path)
				if err != nil {
					t.Fatalf("Failed to parse WAV header: %v", err)
				}
				if metadata.BitsPerSample != tc.bitsPerSample {
					t.Errorf("BitsPerSample incorrect: got %d, want %d", metadata.BitsPerSample, tc.bitsPerSample)
				}
			})
		}
	})
	t.Run("should handle very short durations", func(t *testing.T) {
		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)
		}
	})
	t.Run("should handle long durations", func(t *testing.T) {
		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)
		}
	})
	t.Run("should return error for non-existent file", func(t *testing.T) {
		_, err := ParseWAVHeader("/nonexistent/file.wav")
		if err == nil {
			t.Error("Expected error for non-existent file")
		}
	})
	t.Run("should return error for non-WAV file", func(t *testing.T) {
		// Create a non-WAV file
		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")
		}
	})
	t.Run("should return error for truncated file", func(t *testing.T) {
		// Create a file that's too small to be valid WAV
		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")
		}
	})
	t.Run("should handle empty metadata strings", func(t *testing.T) {
		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)
		}
	})
	t.Run("should handle long comment strings", func(t *testing.T) {
		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)
		}
	})
	t.Run("should extract file modification time", func(t *testing.T) {
		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:        "",
		})
		// Get expected mod time
		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)
		}
		// Ensure FileModTime is not zero
		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("should parse basic WAV metadata", func(t *testing.T) {
		path := createTestWAVFile(t, tmpDir, "test_minimal.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:        "",
		})
		sampleRate, duration, err := ParseWAVHeaderMinimal(path)
		if err != nil {
			t.Fatalf("Failed to parse WAV header: %v", err)
		}
		if sampleRate != 44100 {
			t.Errorf("SampleRate incorrect: got %d, want 44100", sampleRate)
		}
		if duration < 9.9 || duration > 10.1 {
			t.Errorf("Duration incorrect: got %f, want ~10.0", duration)
		}
	})
	t.Run("should handle different sample rates", func(t *testing.T) {
		sampleRates := []int{8000, 22050, 44100, 48000, 96000}
		for _, sr := range sampleRates {
			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:      5.0,
					sampleRate:    sr,
					channels:      1,
					bitsPerSample: 16,
					comment:       "",
					artist:        "",
				})
				sampleRate, duration, err := ParseWAVHeaderMinimal(path)
				if err != nil {
					t.Fatalf("Failed to parse WAV header: %v", err)
				}
				if sampleRate != sr {
					t.Errorf("SampleRate incorrect: got %d, want %d", sampleRate, sr)
				}
				if duration < 4.9 || duration > 5.1 {
					t.Errorf("Duration incorrect: got %f, want ~5.0", duration)
				}
			})
		}
	})
	t.Run("should handle stereo files", func(t *testing.T) {
		path := createTestWAVFile(t, tmpDir, "test_stereo.wav", struct {
			duration      float64
			sampleRate    int
			channels      int
			bitsPerSample int
			comment       string
			artist        string
		}{
			duration:      3.0,
			sampleRate:    44100,
			channels:      2,
			bitsPerSample: 16,
			comment:       "",
			artist:        "",
		})
		sampleRate, duration, err := ParseWAVHeaderMinimal(path)
		if err != nil {
			t.Fatalf("Failed to parse WAV header: %v", err)
		}
		if sampleRate != 44100 {
			t.Errorf("SampleRate incorrect: got %d, want 44100", sampleRate)
		}
		if duration < 2.9 || duration > 3.1 {
			t.Errorf("Duration incorrect: got %f, want ~3.0", duration)
		}
	})
	t.Run("should return error for non-existent file", func(t *testing.T) {
		_, _, err := ParseWAVHeaderMinimal("/nonexistent/file.wav")
		if err == nil {
			t.Error("Expected error for non-existent file")
		}
	})
	t.Run("should return error for non-WAV file", func(t *testing.T) {
		// Create a text file
		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")
		}
	})
}

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
}
// 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.
// ParseWAVHeader extracts metadata from WAV file including duration, sample rate, and INFO chunks
func ParseWAVHeader(filepath string) (*WAVMetadata, error) {
	file, err := os.Open(filepath)
	if err != nil {
		return nil, fmt.Errorf("failed to open file: %w", err)
	}
	defer func() { _ = file.Close() }()
	// Get file info for modification time
	fileInfo, err := file.Stat()
	if err != nil {
		return nil, fmt.Errorf("failed to get file info: %w", err)
	}
	modTime := fileInfo.ModTime()
	fileSize := fileInfo.Size()
	// Get header buffer from pool
	headerBufPtr := getHeaderBuffer()
	defer putHeaderBuffer(headerBufPtr)
	headerBuf := (*headerBufPtr)[:cap(*headerBufPtr)]
	// Read first 200KB for header parsing (more than enough for metadata)
	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
	}
	// Set file modification time and size
	metadata.FileModTime = modTime
	metadata.FileSize = fileSize
	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) {
	file, err := os.Open(filepath)
	if err != nil {
		return 0, 0, fmt.Errorf("failed to open file: %w", err)
	}
	defer func() { _ = file.Close() }()
	// Get minimal header buffer from pool (4KB)
	headerBufPtr := getMinimalHeaderBuffer()
	defer putMinimalHeaderBuffer(headerBufPtr)
	headerBuf := (*headerBufPtr)[:cap(*headerBufPtr)]
	// Read first 4KB - sufficient for fmt + data chunk headers in 99% of files
	n, err := file.Read(headerBuf)
	if err != nil && err != io.EOF {
		return 0, 0, fmt.Errorf("failed to read header: %w", err)
	}
	headerBuf = headerBuf[:n]
	// Parse minimal metadata
	sampleRate, duration, err = parseWAVMinimal(headerBuf)
	if err != nil {
		return 0, 0, err
	}
	return sampleRate, duration, nil
}
// parseWAVMinimal parses only essential WAV metadata from a byte buffer.
// Returns (sampleRate, duration, error). Does not parse INFO chunks.
func parseWAVMinimal(data []byte) (sampleRate int, duration float64, err error) {
	if len(data) < 44 {
		return 0, 0, fmt.Errorf("file too small to be valid WAV")
	}
	// Verify RIFF header
	if string(data[0:4]) != "RIFF" {
		return 0, 0, fmt.Errorf("not a valid WAV file (missing RIFF header)")
	}
	// Verify WAVE format
	if string(data[8:12]) != "WAVE" {
		return 0, 0, fmt.Errorf("not a valid WAV file (missing WAVE format)")
	}
	var channels, bitsPerSample int
	// Parse chunks - stop after finding data chunk
	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 ":
			// Parse format chunk
			if chunkSize >= 16 && offset+16 <= len(data) {
				channels = int(binary.LittleEndian.Uint16(data[offset+2 : offset+4]))
				sampleRate = int(binary.LittleEndian.Uint32(data[offset+4 : offset+8]))
				bitsPerSample = int(binary.LittleEndian.Uint16(data[offset+14 : offset+16]))
			}
		case "data":
			// Found data chunk - calculate duration and return
			if sampleRate > 0 && channels > 0 && bitsPerSample > 0 {
				bytesPerSample := bitsPerSample / 8
				bytesPerSecond := sampleRate * channels * bytesPerSample
				if bytesPerSecond > 0 {
					duration = float64(chunkSize) / float64(bytesPerSecond)
					return sampleRate, duration, nil
				}
			}
			return 0, 0, fmt.Errorf("invalid WAV: fmt chunk missing or corrupt before data chunk")
		}
		// Move to next chunk (word-aligned)
		offset += chunkSize
		if chunkSize%2 != 0 {
			offset++
		}
	}
	// Data chunk not found within 4KB - file may have large INFO chunks
	return 0, 0, fmt.Errorf("data chunk not found in first 4KB (try ParseWAVHeader for full parsing)")
}
// 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() }()
	// Get file info for modification time and size
	fileInfo, err := file.Stat()
	if err != nil {
		return nil, "", fmt.Errorf("failed to get file info: %w", err)
	}
	modTime := fileInfo.ModTime()
	fileSize := fileInfo.Size()
	// Get header buffer from pool
	headerBufPtr := getHeaderBuffer()
	defer putHeaderBuffer(headerBufPtr)
	headerBuf := (*headerBufPtr)[:cap(*headerBufPtr)]
	// Read first 200KB for header parsing
	n, err := file.Read(headerBuf)
	if err != nil && err != io.EOF {
		return nil, "", fmt.Errorf("failed to read header: %w", err)
	}
	headerBuf = headerBuf[:n]
	// Parse header
	metadata, err := parseWAVFromBytes(headerBuf)
	if err != nil {
		return nil, "", err
	}
	metadata.FileModTime = modTime
	metadata.FileSize = fileSize
	// 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)
	}
	// Get hash buffer from pool
	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")
	}
	// Verify RIFF header
	if string(data[0:4]) != "RIFF" {
		return nil, fmt.Errorf("not a valid WAV file (missing RIFF header)")
	}
	// Verify WAVE format
	if string(data[8:12]) != "WAVE" {
		return nil, fmt.Errorf("not a valid WAV file (missing WAVE format)")
	}
	metadata := &WAVMetadata{}
	// Parse chunks
	offset := 12
	for offset < len(data)-8 {
		// Read chunk ID and size
		chunkID := string(data[offset : offset+4])
		chunkSize := int(binary.LittleEndian.Uint32(data[offset+4 : offset+8]))
		offset += 8
		switch chunkID {
		case "fmt ":
			// Parse format chunk - need at least 16 bytes of data
			if chunkSize >= 16 && offset+16 <= len(data) {
				metadata.Channels = int(binary.LittleEndian.Uint16(data[offset+2 : offset+4]))
				metadata.SampleRate = int(binary.LittleEndian.Uint32(data[offset+4 : offset+8]))
				metadata.BitsPerSample = int(binary.LittleEndian.Uint16(data[offset+14 : offset+16]))
			}
		case "data":
			// Calculate duration from data chunk size
			// We only need the chunkSize from the header, not the actual audio data
			if metadata.SampleRate > 0 && metadata.Channels > 0 && metadata.BitsPerSample > 0 {
				bytesPerSample := metadata.BitsPerSample / 8
				bytesPerSecond := metadata.SampleRate * metadata.Channels * bytesPerSample
				if bytesPerSecond > 0 {
					metadata.Duration = float64(chunkSize) / float64(bytesPerSecond)
				}
			}
			// Data chunk content is the audio data - we don't need to read it
		case "LIST":
			// Parse LIST chunk for INFO metadata
			if chunkSize >= 4 && offset+chunkSize <= len(data) {
				listType := string(data[offset : offset+4])
				if listType == "INFO" {
					parseINFOChunk(data[offset+4:offset+chunkSize], metadata)
				}
			}
		}
		// Move to next chunk (chunks are word-aligned)
		offset += chunkSize
		if chunkSize%2 != 0 {
			offset++ // Skip padding byte
		}
	}
	// Validate that we found essential chunks
	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
}
// 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)
}
// 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) {
	file, err := os.Open(filepath)
	if err != nil {
		return nil, 0, fmt.Errorf("failed to open file: %w", err)
	}
	defer func() { _ = file.Close() }()
	// Read header to get format info
	headerBuf := make([]byte, 44)
	if _, err := io.ReadFull(file, headerBuf); err != nil {
		return nil, 0, fmt.Errorf("failed to read header: %w", err)
	}
	// Verify RIFF/WAVE header
	if string(headerBuf[0:4]) != "RIFF" || string(headerBuf[8:12]) != "WAVE" {
		return nil, 0, fmt.Errorf("not a valid WAV file")
	}
	// Parse chunks to find fmt and data
	var sampleRate, channels, bitsPerSample int
	var dataOffset, dataSize int64
	// Seek to first chunk
	if _, err := file.Seek(12, 0); err != nil {
		return nil, 0, fmt.Errorf("failed to seek: %w", err)
	}
	for {
		chunkHeader := make([]byte, 8)
		if _, err := io.ReadFull(file, chunkHeader); err != nil {
			if err == io.EOF {
				break
			}
			return nil, 0, 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 nil, 0, fmt.Errorf("failed to read fmt chunk: %w", err)
			}
			if len(fmtData) >= 16 {
				channels = int(binary.LittleEndian.Uint16(fmtData[2:4]))
				sampleRate = int(binary.LittleEndian.Uint32(fmtData[4:8]))
				bitsPerSample = int(binary.LittleEndian.Uint16(fmtData[14:16]))
			}
		case "data":
			dataOffset, _ = file.Seek(0, 1) // Current position
			dataSize = chunkSize
			// Done - we found the data chunk
			goto foundData
		default:
			// Skip unknown chunk
			if _, err := file.Seek(chunkSize, 1); err != nil {
				return nil, 0, fmt.Errorf("failed to skip chunk: %w", err)
			}
		}
		// Word align
		if chunkSize%2 != 0 {
			if _, err := file.Seek(1, 1); err != nil {
				return nil, 0, fmt.Errorf("failed to skip padding: %w", err)
			}
		}
	}
	return nil, 0, fmt.Errorf("no data chunk found in WAV file")
foundData:
	if sampleRate == 0 || channels == 0 || bitsPerSample == 0 {
		return nil, 0, fmt.Errorf("missing or invalid fmt chunk")
	}
	// Read audio data
	if _, err := file.Seek(dataOffset, 0); err != nil {
		return nil, 0, fmt.Errorf("failed to seek to data: %w", err)
	}
	audioData := make([]byte, dataSize)
	if _, err := io.ReadFull(file, audioData); err != nil {
		return nil, 0, fmt.Errorf("failed to read audio data: %w", err)
	}
	// Convert to float64 samples
	samples := convertToFloat64(audioData, bitsPerSample, channels)
	return samples, 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
}

package utils
import (
	"testing"
)
func TestValidateShortID(t *testing.T) {
	tests := []struct {
		name      string
		id        string
		fieldName string
		wantErr   bool
	}{
		{"valid 12-char ID", "abc123XYZ789", "test_id", false},
		{"valid with underscore", "abc_123_XYZ_", "test_id", false},
		{"valid with dash", "abc-123-XYZ-", "test_id", false},
		{"empty string", "", "test_id", true},
		{"too short", "abc123", "test_id", true},
		{"too long", "abc123XYZ789toolong", "test_id", true},
		{"invalid chars", "abc@123#XYZ$", "test_id", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateShortID(tt.id, tt.fieldName)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateShortID() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateStringLength(t *testing.T) {
	tests := []struct {
		name    string
		value   string
		field   string
		maxLen  int
		wantErr bool
	}{
		{"within limit", "hello", "test", 10, false},
		{"at limit", "1234567890", "test", 10, false},
		{"empty string", "", "test", 10, false},
		{"over limit", "12345678901", "test", 10, true},
		{"zero max", "a", "test", 0, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateStringLength(tt.value, tt.field, tt.maxLen)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateStringLength() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateRange(t *testing.T) {
	t.Run("int range", func(t *testing.T) {
		tests := []struct {
			name    string
			value   int
			min     int
			max     int
			wantErr bool
		}{
			{"within range", 50, 0, 100, false},
			{"at min", 0, 0, 100, false},
			{"at max", 100, 0, 100, false},
			{"below min", -1, 0, 100, true},
			{"above max", 101, 0, 100, true},
		}
		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				err := ValidateRange(tt.value, "test", tt.min, tt.max)
				if (err != nil) != tt.wantErr {
					t.Errorf("ValidateRange() error = %v, wantErr %v", err, tt.wantErr)
				}
			})
		}
	})
	t.Run("float64 range", func(t *testing.T) {
		tests := []struct {
			name    string
			value   float64
			min     float64
			max     float64
			wantErr bool
		}{
			{"within range", 45.5, -90.0, 90.0, false},
			{"at min", -90.0, -90.0, 90.0, false},
			{"at max", 90.0, -90.0, 90.0, false},
			{"below min", -90.1, -90.0, 90.0, true},
			{"above max", 90.1, -90.0, 90.0, true},
		}
		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				err := ValidateRange(tt.value, "test", tt.min, tt.max)
				if (err != nil) != tt.wantErr {
					t.Errorf("ValidateRange() error = %v, wantErr %v", err, tt.wantErr)
				}
			})
		}
	})
}
func TestValidatePositive(t *testing.T) {
	tests := []struct {
		name    string
		value   int
		wantErr bool
	}{
		{"positive", 1, false},
		{"large positive", 1000000, false},
		{"zero", 0, true},
		{"negative", -1, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidatePositive(tt.value, "test")
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidatePositive() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateSampleRate(t *testing.T) {
	tests := []struct {
		name    string
		rate    int
		wantErr bool
	}{
		{"valid low", 1000, false},
		{"valid typical", 48000, false},
		{"valid high", 250000, false},
		{"valid max", 500000, false},
		{"too low", 999, true},
		{"too high", 500001, true},
		{"zero", 0, true},
		{"negative", -1000, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateSampleRate(tt.rate)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateSampleRate() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateTimezone(t *testing.T) {
	tests := []struct {
		name    string
		tz      string
		wantErr bool
	}{
		{"valid Auckland", "Pacific/Auckland", false},
		{"valid UTC", "UTC", false},
		{"valid America/New_York", "America/New_York", false},
		{"valid Europe/London", "Europe/London", false},
		{"invalid", "Invalid/Timezone", true},
		{"garbage", "not-a-timezone", true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateTimezone(tt.tz)
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateTimezone() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}
func TestValidateNonNegative(t *testing.T) {
	tests := []struct {
		name    string
		value   int
		wantErr bool
	}{
		{"positive", 1, false},
		{"zero", 0, false},
		{"negative", -1, true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateNonNegative(tt.value, "test")
			if (err != nil) != tt.wantErr {
				t.Errorf("ValidateNonNegative() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

package utils
import (
	"database/sql"
	"fmt"
	"regexp"
	"time"
)
// ID length constants matching nanoid generation
const (
	ShortIDLen = 12 // dataset, location, cluster, pattern, species, filter, call_type
)
// Sample rate reasonable bounds for audio recording
const (
	MinSampleRate = 1000   // 1 kHz - below this is unlikely to be real audio
	MaxSampleRate = 500000 // 500 kHz - well above bat detectors (~250kHz)
)
// Max string lengths from schema
const (
	MaxNameLen        = 140 // location.name, cluster.name
	MaxDatasetNameLen = 255 // dataset.name
	MaxDescriptionLen = 255 // all description fields
	MaxPathLen        = 255 // cluster.path
	MaxFileNameLen    = 255 // file.file_name
	MaxTimezoneLen    = 40  // location.timezone_id
)
// ID format regex - alphanumeric characters (nanoid uses A-Za-z0-9_)
var shortIDRegex = regexp.MustCompile(`^[A-Za-z0-9_-]{12}$`)
// ValidateShortID validates 12-character nanoid format
func ValidateShortID(id, fieldName string) error {
	if id == "" {
		return fmt.Errorf("%s cannot be empty", fieldName)
	}
	if len(id) != ShortIDLen {
		return fmt.Errorf("%s must be exactly %d characters (got %d)", fieldName, ShortIDLen, len(id))
	}
	if !shortIDRegex.MatchString(id) {
		return fmt.Errorf("%s has invalid format (expected alphanumeric nanoid)", fieldName)
	}
	return nil
}
// ValidateOptionalShortID validates short ID if provided (non-empty)
func ValidateOptionalShortID(id *string, fieldName string) error {
	if id == nil || *id == "" {
		return nil
	}
	return ValidateShortID(*id, fieldName)
}
// ValidateStringLength validates string length constraint
func ValidateStringLength(value, fieldName string, maxLen int) error {
	if len(value) > maxLen {
		return fmt.Errorf("%s must be %d characters or less (got %d)", fieldName, maxLen, len(value))
	}
	return nil
}
// ValidateOptionalStringLength validates string length if provided
func ValidateOptionalStringLength(value *string, fieldName string, maxLen int) error {
	if value == nil || *value == "" {
		return nil
	}
	return ValidateStringLength(*value, fieldName, maxLen)
}
// ValidateRange validates numeric range constraint (inclusive)
func ValidateRange[T int | float64](value T, fieldName string, min, max T) error {
	if value < min || value > max {
		return fmt.Errorf("%s must be between %v and %v (got %v)", fieldName, min, max, value)
	}
	return nil
}
// ValidatePositive validates positive number (> 0)
func ValidatePositive[T int | float64](value T, fieldName string) error {
	if value <= 0 {
		return fmt.Errorf("%s must be positive (got %v)", fieldName, value)
	}
	return nil
}
// ValidateNonNegative validates non-negative number (>= 0)
func ValidateNonNegative[T int | float64](value T, fieldName string) error {
	if value < 0 {
		return fmt.Errorf("%s must be non-negative (got %v)", fieldName, value)
	}
	return nil
}
// ValidateSampleRate validates audio sample rate is in reasonable range
func ValidateSampleRate(rate int) error {
	return ValidateRange(rate, "sample_rate", MinSampleRate, MaxSampleRate)
}
// ValidateTimezone validates IANA timezone ID
func ValidateTimezone(tzID string) error {
	if _, err := time.LoadLocation(tzID); err != nil {
		return fmt.Errorf("invalid timezone_id '%s': %w", tzID, err)
	}
	return nil
}
// GetDatasetType returns the type of a dataset
// Returns: (type, exists, error)
func GetDatasetType(db *sql.DB, datasetID string) (string, bool, error) {
	var datasetType string
	err := db.QueryRow("SELECT type FROM dataset WHERE id = ?", datasetID).Scan(&datasetType)
	if err == sql.ErrNoRows {
		return "", false, nil
	}
	if err != nil {
		return "", false, err
	}
	return datasetType, true, nil
}
// ValidateDatasetTypeForImport checks that a dataset is 'structured' type for file imports
// Returns error if dataset doesn't exist or is not 'structured'
func ValidateDatasetTypeForImport(db *sql.DB, datasetID string) error {
	datasetType, exists, err := GetDatasetType(db, datasetID)
	if err != nil {
		return fmt.Errorf("failed to query dataset type: %w", err)
	}
	if !exists {
		return fmt.Errorf("dataset not found: %s", datasetID)
	}
	if datasetType != "structured" {
		return fmt.Errorf("dataset '%s' is type '%s' - file imports only support 'structured' datasets", datasetID, datasetType)
	}
	return nil
}
// ValidateDatasetTypeUnstructured checks that a dataset is 'unstructured' type
// Returns error if dataset doesn't exist or is not 'unstructured'
func ValidateDatasetTypeUnstructured(db *sql.DB, datasetID string) error {
	datasetType, exists, err := GetDatasetType(db, datasetID)
	if err != nil {
		return fmt.Errorf("failed to query dataset type: %w", err)
	}
	if !exists {
		return fmt.Errorf("dataset not found: %s", datasetID)
	}
	if datasetType != "unstructured" {
		return fmt.Errorf("dataset '%s' is type '%s' - this command only supports 'unstructured' datasets", datasetID, datasetType)
	}
	return nil
}
// ValidateLocationBelongsToDataset checks that a location belongs to a specific dataset
// Returns error if location doesn't exist or belongs to a different dataset
func ValidateLocationBelongsToDataset(db *sql.DB, locationID, datasetID string) error {
	var locationDatasetID string
	err := db.QueryRow("SELECT dataset_id FROM location WHERE id = ? AND active = true", locationID).Scan(&locationDatasetID)
	if err == sql.ErrNoRows {
		return fmt.Errorf("location not found or inactive: %s", locationID)
	}
	if err != nil {
		return fmt.Errorf("failed to query location: %w", err)
	}
	if locationDatasetID != datasetID {
		return fmt.Errorf("location %s does not belong to dataset %s", locationID, datasetID)
	}
	return nil
}

package utils
import (
	"image"
	"image/color"
	"math/rand"
	"strings"
	"testing"
)
func TestWriteKittyImage_SmallImage(t *testing.T) {
	// 2x2 image produces small base64 payload — single chunk, no m= key
	img := image.NewGray(image.Rect(0, 0, 2, 2))
	img.SetGray(0, 0, color.Gray{Y: 128})
	var buf strings.Builder
	if err := WriteKittyImage(img, &buf); err != nil {
		t.Fatalf("WriteKittyImage: %v", err)
	}
	out := buf.String()
	if !strings.HasPrefix(out, "\x1b_Gf=100,a=T;") {
		t.Error("expected single-chunk header with f=100,a=T")
	}
	if strings.Contains(out, "m=") {
		t.Error("small image should not use chunked m= key")
	}
	if !strings.HasSuffix(out, "\x1b\\") {
		t.Error("expected escape sequence terminator")
	}
}
func TestWriteKittyImage_LargeImage_Chunked(t *testing.T) {
	// 128x128 random noise image is incompressible — produces >4096 bytes of base64 even with proper LZ77
	rng := rand.New(rand.NewSource(42))
	img := image.NewGray(image.Rect(0, 0, 128, 128))
	for y := range 128 {
		for x := range 128 {
			img.SetGray(x, y, color.Gray{Y: uint8(rng.Intn(256))})
		}
	}
	var buf strings.Builder
	if err := WriteKittyImage(img, &buf); err != nil {
		t.Fatalf("WriteKittyImage: %v", err)
	}
	out := buf.String()
	// Should have multiple escape sequences
	chunks := strings.Split(out, "\x1b\\")
	// Last element is empty after final terminator
	chunks = chunks[:len(chunks)-1]
	if len(chunks) < 2 {
		t.Fatalf("expected multiple chunks, got %d", len(chunks))
	}
	// First chunk should have f=100,a=T,m=1
	if !strings.Contains(chunks[0], "f=100,a=T,m=1") {
		t.Errorf("first chunk missing f=100,a=T,m=1: %s", chunks[0][:min(80, len(chunks[0]))])
	}
	// Last chunk should have m=0
	last := chunks[len(chunks)-1]
	if !strings.Contains(last, "\x1b_Gm=0;") {
		t.Errorf("last chunk missing m=0: %s", last[:min(80, len(last))])
	}
	// Middle chunks should have m=1
	for i := 1; i < len(chunks)-1; i++ {
		if !strings.Contains(chunks[i], "\x1b_Gm=1;") {
			t.Errorf("middle chunk %d missing m=1", i)
		}
	}
}
func TestClearKittyImages(t *testing.T) {
	var buf strings.Builder
	ClearKittyImages(&buf)
	expected := "\x1b_Ga=d\x1b\\"
	if buf.String() != expected {
		t.Errorf("got %q, want %q", buf.String(), expected)
	}
}
func TestWriteSixelImage(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 4, 6))
	for y := range 6 {
		for x := range 4 {
			img.SetGray(x, y, color.Gray{Y: uint8((x + y) * 40)})
		}
	}
	var buf strings.Builder
	if err := WriteSixelImage(img, &buf); err != nil {
		t.Fatalf("WriteSixelImage: %v", err)
	}
	out := buf.String()
	// Sixel DCS introducer
	if !strings.HasPrefix(out, "\x1bP") {
		t.Error("expected DCS prefix \\x1bP")
	}
	// String terminator
	if !strings.HasSuffix(out, "\x1b\\") {
		t.Error("expected ST suffix \\x1b\\\\")
	}
	// Should contain 'q' after DCS parameters
	if !strings.Contains(out, "q") {
		t.Error("expected 'q' in DCS sequence")
	}
}
func TestClearImages_Kitty(t *testing.T) {
	var buf strings.Builder
	ClearImages(&buf, ProtocolKitty)
	if buf.String() != "\x1b_Ga=d\x1b\\" {
		t.Errorf("got %q, want kitty clear sequence", buf.String())
	}
}
func TestClearImages_Sixel(t *testing.T) {
	var buf strings.Builder
	ClearImages(&buf, ProtocolSixel)
	if buf.String() != "" {
		t.Errorf("expected no output for sixel clear, got %q", buf.String())
	}
}
func TestWriteImage_Kitty(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 2, 2))
	var buf strings.Builder
	if err := WriteImage(img, &buf, ProtocolKitty); err != nil {
		t.Fatalf("WriteImage kitty: %v", err)
	}
	if !strings.HasPrefix(buf.String(), "\x1b_G") {
		t.Error("expected kitty escape prefix")
	}
}
func TestWriteImage_Sixel(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 4, 6))
	var buf strings.Builder
	if err := WriteImage(img, &buf, ProtocolSixel); err != nil {
		t.Fatalf("WriteImage sixel: %v", err)
	}
	if !strings.HasPrefix(buf.String(), "\x1bP") {
		t.Error("expected sixel DCS prefix")
	}
}
func TestWriteITermImage(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 4, 4))
	img.SetGray(0, 0, color.Gray{Y: 128})
	var buf strings.Builder
	if err := WriteITermImage(img, &buf); err != nil {
		t.Fatalf("WriteITermImage: %v", err)
	}
	out := buf.String()
	if !strings.HasPrefix(out, "\x1b]1337;File=") {
		t.Errorf("expected iTerm2 OSC prefix, got %q", out[:min(30, len(out))])
	}
	if !strings.Contains(out, "inline=1") {
		t.Error("expected inline=1 parameter")
	}
	if !strings.HasSuffix(out, "\x07") {
		t.Error("expected BEL terminator")
	}
}
func TestWriteImage_ITerm(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 4, 4))
	var buf strings.Builder
	if err := WriteImage(img, &buf, ProtocolITerm); err != nil {
		t.Fatalf("WriteImage iterm: %v", err)
	}
	if !strings.HasPrefix(buf.String(), "\x1b]1337;File=") {
		t.Error("expected iTerm2 OSC prefix")
	}
}
func TestClearImages_ITerm(t *testing.T) {
	var buf strings.Builder
	ClearImages(&buf, ProtocolITerm)
	if buf.String() != "" {
		t.Errorf("expected no output for iTerm2 clear, got %q", buf.String())
	}
}

package utils
import (
	"bytes"
	"encoding/base64"
	"image"
	"image/color"
	"image/png"
	"io"
	"github.com/charmbracelet/x/ansi"
	"github.com/charmbracelet/x/ansi/iterm2"
	"github.com/charmbracelet/x/ansi/kitty"
	"github.com/charmbracelet/x/ansi/sixel"
)
// ImageProtocol selects the terminal graphics protocol.
type ImageProtocol int
const (
	ProtocolKitty ImageProtocol = iota
	ProtocolSixel
	ProtocolITerm
)
// SpectrogramDisplaySize is the default pixel dimension for spectrogram images.
// 448px suits Retina/HiDPI screens (224 logical pixels at 2x).
const SpectrogramDisplaySize = 448
// ClampImageSize clamps a dimension to [224, 448].
func ClampImageSize(size int) int {
	return max(224, min(896, size))
}
// WriteImage writes an image using the specified terminal graphics protocol.
func WriteImage(img image.Image, w io.Writer, protocol ImageProtocol) error {
	switch protocol {
	case ProtocolSixel:
		return WriteSixelImage(img, w)
	case ProtocolITerm:
		return WriteITermImage(img, w)
	default:
		return WriteKittyImage(img, w)
	}
}
// ClearImages clears previously displayed images.
// For kitty, deletes all image placements. For sixel/iTerm2, no-op (inline text).
func ClearImages(w io.Writer, protocol ImageProtocol) error {
	switch protocol {
	case ProtocolKitty:
		return ClearKittyImages(w)
	default:
		return nil
	}
}
// ClearKittyImages clears all previously displayed Kitty images
func ClearKittyImages(w io.Writer) error {
	_, err := io.WriteString(w, ansi.KittyGraphics(nil, "a=d"))
	return err
}
// WriteKittyImage writes an image to the writer using the Kitty graphics protocol.
// The image is encoded as PNG, base64'd, and sent via chunked Kitty escape sequences.
func WriteKittyImage(img image.Image, w io.Writer) error {
	return kitty.EncodeGraphics(w, img, &kitty.Options{
		Format:       kitty.PNG,
		Action:       kitty.TransmitAndPut,
		Transmission: kitty.Direct,
		Chunk:        true,
	})
}
// WriteSixelImage writes an image using the Sixel graphics protocol.
func WriteSixelImage(img image.Image, w io.Writer) error {
	var buf bytes.Buffer
	enc := &sixel.Encoder{}
	if err := enc.Encode(&buf, img); err != nil {
		return err
	}
	_, err := io.WriteString(w, ansi.SixelGraphics(0, 1, 0, buf.Bytes()))
	return err
}
// WriteITermImage writes an image using the iTerm2 Inline Image Protocol.
func WriteITermImage(img image.Image, w io.Writer) error {
	var buf bytes.Buffer
	if err := png.Encode(&buf, img); err != nil {
		return err
	}
	b64 := base64.StdEncoding.EncodeToString(buf.Bytes())
	_, err := io.WriteString(w, ansi.ITerm2(iterm2.File{
		Inline:  true,
		Content: []byte(b64),
	}))
	return err
}
// CreateGrayscaleImage creates an image.Image from a 2D uint8 array.
// The array is organized as [rows][cols] where rows = frequency bins.
func CreateGrayscaleImage(data [][]uint8) image.Image {
	if len(data) == 0 || len(data[0]) == 0 {
		return nil
	}
	height := len(data)
	width := len(data[0])
	img := image.NewGray(image.Rect(0, 0, width, height))
	for y := range height {
		off := y * img.Stride
		row := data[y]
		copy(img.Pix[off:off+width], row)
	}
	return img
}
// CreateRGBImage creates an image.Image from a 2D RGBPixel array.
// The array is organized as [rows][cols] where rows = frequency bins.
func CreateRGBImage(data [][]RGBPixel) image.Image {
	if len(data) == 0 || len(data[0]) == 0 {
		return nil
	}
	height := len(data)
	width := len(data[0])
	img := image.NewRGBA(image.Rect(0, 0, width, height))
	for y := range height {
		off := y * img.Stride
		row := data[y]
		for x := range width {
			i := off + x*4
			img.Pix[i] = row[x].R
			img.Pix[i+1] = row[x].G
			img.Pix[i+2] = row[x].B
			img.Pix[i+3] = 255
		}
	}
	return img
}
// ResizeImage resizes an image using nearest-neighbor interpolation.
// For higher quality, use golang.org/x/image/draw, but this keeps dependencies minimal.
func ResizeImage(img image.Image, newWidth, newHeight int) image.Image {
	bounds := img.Bounds()
	srcWidth := bounds.Dx()
	srcHeight := bounds.Dy()
	scaleX := float64(srcWidth) / float64(newWidth)
	scaleY := float64(srcHeight) / float64(newHeight)
	if srcGray, ok := img.(*image.Gray); ok {
		result := image.NewGray(image.Rect(0, 0, newWidth, newHeight))
		for y := range newHeight {
			srcY := int(float64(y) * scaleY)
			if srcY >= srcHeight {
				srcY = srcHeight - 1
			}
			dstOff := y * result.Stride
			srcRowOff := srcY * srcGray.Stride
			for x := range newWidth {
				srcX := int(float64(x) * scaleX)
				if srcX >= srcWidth {
					srcX = srcWidth - 1
				}
				result.Pix[dstOff+x] = srcGray.Pix[srcRowOff+srcX]
			}
		}
		return result
	}
	if srcRGBA, ok := img.(*image.RGBA); ok {
		result := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
		for y := range newHeight {
			srcY := int(float64(y) * scaleY)
			if srcY >= srcHeight {
				srcY = srcHeight - 1
			}
			dstOff := y * result.Stride
			srcRowOff := srcY * srcRGBA.Stride
			for x := range newWidth {
				srcX := int(float64(x) * scaleX)
				if srcX >= srcWidth {
					srcX = srcWidth - 1
				}
				si := srcRowOff + srcX*4
				di := dstOff + x*4
				result.Pix[di] = srcRGBA.Pix[si]
				result.Pix[di+1] = srcRGBA.Pix[si+1]
				result.Pix[di+2] = srcRGBA.Pix[si+2]
				result.Pix[di+3] = srcRGBA.Pix[si+3]
			}
		}
		return result
	}
	// Fallback for other image types
	result := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
	for y := range newHeight {
		srcY := int(float64(y) * scaleY)
		if srcY >= srcHeight {
			srcY = srcHeight - 1
		}
		for x := range newWidth {
			srcX := int(float64(x) * scaleX)
			if srcX >= srcWidth {
				srcX = srcWidth - 1
			}
			c := img.At(srcX+bounds.Min.X, srcY+bounds.Min.Y)
			r, g, b, _ := c.RGBA()
			result.SetRGBA(x, y, color.RGBA{
				R: uint8(r >> 8),
				G: uint8(g >> 8),
				B: uint8(b >> 8),
				A: 255,
			})
		}
	}
	return result
}
// WritePNG writes an image to a writer in PNG format using fast compression.
func WritePNG(img image.Image, w io.Writer) error {
	enc := &png.Encoder{CompressionLevel: png.BestSpeed}
	return enc.Encode(w, img)
}

package utils
import (
	"image"
	"math"
	"strings"
	"sync"
	"github.com/madelynnblue/go-dsp/window"
)
// cached Hann windows by size, computed once
var (
	hannCache   = map[int][]float64{}
	hannCacheMu sync.RWMutex
)
// getCachedHannWindow returns a cached Hann window of the given size.
func getCachedHannWindow(size int) []float64 {
	hannCacheMu.RLock()
	if w, ok := hannCache[size]; ok {
		hannCacheMu.RUnlock()
		return w
	}
	hannCacheMu.RUnlock()
	hannCacheMu.Lock()
	defer hannCacheMu.Unlock()
	// Double-check after acquiring write lock
	if w, ok := hannCache[size]; ok {
		return w
	}
	w := window.Hann(size)
	hannCache[size] = w
	return w
}
// DefaultMaxSampleRate is the maximum sample rate for spectrograms.
// Higher sample rates are downsampled to this rate for better visualization.
const DefaultMaxSampleRate = 16000
// SpectrogramConfig holds STFT parameters
type SpectrogramConfig struct {
	WindowSize int // FFT window size (e.g., 400)
	HopSize    int // Hop between windows (e.g., 200 for 50% overlap)
	SampleRate int // Sample rate in Hz
}
// DefaultSpectrogramConfig returns default config matching Julia implementation
func DefaultSpectrogramConfig(sampleRate int) SpectrogramConfig {
	return SpectrogramConfig{
		WindowSize: 512,
		HopSize:    256, // 50% overlap (window/2)
		SampleRate: sampleRate,
	}
}
// GenerateSpectrogram generates a spectrogram from audio samples.
// Returns a 2D array of uint8 (0-255) where:
// - First dimension is frequency bins (rows)
// - Second dimension is time frames (columns)
func GenerateSpectrogram(samples []float64, cfg SpectrogramConfig) [][]uint8 {
	if len(samples) < cfg.WindowSize {
		return nil
	}
	// Get cached Hann window
	hannWindow := getCachedHannWindow(cfg.WindowSize)
	// Calculate number of frames
	numFrames := (len(samples)-cfg.WindowSize)/cfg.HopSize + 1
	if numFrames <= 0 {
		return nil
	}
	// Number of frequency bins (half of FFT due to symmetry)
	numFreqBins := cfg.WindowSize/2 + 1
	// Allocate power spectrum as flat backing slice (single allocation)
	powerFlat := make([]float64, numFreqBins*numFrames)
	// Pre-allocate scratch buffers (reused across all frames — zero allocs in loop)
	frameData := make([]float64, cfg.WindowSize)
	scratch := make([]complex128, cfg.WindowSize)
	framePower := make([]float64, numFreqBins)
	// Perform STFT
	for frame := range numFrames {
		start := frame * cfg.HopSize
		// Extract and window the frame
		for i := 0; i < cfg.WindowSize; i++ {
			frameData[i] = samples[start+i] * hannWindow[i]
		}
		// Compute power spectrum via inline FFT (zero allocations)
		PowerSpectrumFFT(frameData, framePower, scratch)
		// Copy power into flat matrix (freq bins x time frames layout)
		for bin := range numFreqBins {
			powerFlat[bin*numFrames+frame] = framePower[bin]
		}
	}
	// Fused normalization: replace zeros, convert to dB, find min/max, normalize to uint8
	// All in 2 passes instead of 6
	return normalizeFlat(powerFlat, numFreqBins, numFrames)
}
// normalizeFlat converts power values to dB, normalizes to 0-255, in 2 passes.
// Operates on a flat slice laid out as [row0_col0, row0_col1, ..., row1_col0, ...].
// Returns [][]uint8 with rows flipped vertically (low frequencies at bottom).
func normalizeFlat(power []float64, rows, cols int) [][]uint8 {
	if rows == 0 || cols == 0 {
		return nil
	}
	// Pass 1: find minNonZero, then convert power to dB in-place, tracking min/max dB
	minNonZero := math.MaxFloat64
	for _, val := range power {
		if val > 0 && val < minNonZero {
			minNonZero = val
		}
	}
	if minNonZero == math.MaxFloat64 {
		minNonZero = 1e-20 // fallback floor
	}
	minDB := math.MaxFloat64
	maxDB := -math.MaxFloat64
	for i, val := range power {
		if val <= 0 {
			val = minNonZero
		}
		db := 10.0 * math.Log10(val)
		power[i] = db
		if db < minDB {
			minDB = db
		}
		if db > maxDB {
			maxDB = db
		}
	}
	// Pass 2: normalize dB to uint8 and write into result (with vertical flip)
	rangeDB := maxDB - minDB
	if rangeDB == 0 {
		rangeDB = 1
	}
	scale := 255.0 / rangeDB
	// Allocate result with flat backing slice (single allocation)
	resultFlat := make([]uint8, rows*cols)
	result := make([][]uint8, rows)
	for i := range result {
		// Flip: row i in result gets data from row (rows-1-i) in power
		srcRow := rows - 1 - i
		result[i] = resultFlat[i*cols : (i+1)*cols]
		srcOff := srcRow * cols
		for j := range cols {
			result[i][j] = uint8((power[srcOff+j] - minDB) * scale)
		}
	}
	return result
}
// ExtractSegmentSamples extracts samples from a time range
func ExtractSegmentSamples(samples []float64, sampleRate int, startSec, endSec float64) []float64 {
	startIdx := int(startSec * float64(sampleRate))
	endIdx := int(endSec * float64(sampleRate))
	if startIdx < 0 {
		startIdx = 0
	}
	if endIdx > len(samples) {
		endIdx = len(samples)
	}
	if startIdx >= endIdx {
		return nil
	}
	return samples[startIdx:endIdx]
}
// GenerateSegmentSpectrogram generates a spectrogram image for a time segment.
// Handles WAV loading, downsampling, and image creation.
// color=true applies L4 colormap, color=false creates grayscale.
// imgSize specifies the output image dimensions (clamped to [224, 896]).
func GenerateSegmentSpectrogram(dataFilePath string, startTime, endTime float64, color bool, imgSize int) (image.Image, error) {
	// Derive WAV file path (strip .data suffix)
	wavPath := strings.TrimSuffix(dataFilePath, ".data")
	// Read WAV samples
	samples, sampleRate, err := ReadWAVSamples(wavPath)
	if err != nil {
		return nil, err
	}
	// Extract segment samples
	segSamples := ExtractSegmentSamples(samples, sampleRate, startTime, endTime)
	if len(segSamples) == 0 {
		return nil, nil
	}
	// For spectrograms, downsample if sample rate exceeds 16kHz
	spectSampleRate := sampleRate
	if sampleRate > DefaultMaxSampleRate {
		segSamples = ResampleRate(segSamples, sampleRate, DefaultMaxSampleRate)
		spectSampleRate = DefaultMaxSampleRate
	}
	// Generate spectrogram
	config := DefaultSpectrogramConfig(spectSampleRate)
	spectrogram := GenerateSpectrogram(segSamples, config)
	if spectrogram == nil {
		return nil, nil
	}
	// Create image (grayscale or color)
	var img image.Image
	if color {
		colorData := ApplyL4Colormap(spectrogram)
		img = CreateRGBImage(colorData)
	} else {
		img = CreateGrayscaleImage(spectrogram)
	}
	if img == nil {
		return nil, nil
	}
	// Resize
	imgSize = ClampImageSize(imgSize)
	return ResizeImage(img, imgSize, imgSize), nil
}

package utils
import (
	"math"
	"testing"
)
func TestResampleRate(t *testing.T) {
	t.Run("should return same samples for same rate", func(t *testing.T) {
		samples := []float64{0.1, 0.2, 0.3, 0.4, 0.5}
		result := ResampleRate(samples, 16000, 16000)
		if len(result) != len(samples) {
			t.Errorf("length mismatch: got %d, want %d", len(result), len(samples))
		}
		for i := range samples {
			if result[i] != samples[i] {
				t.Errorf("sample %d mismatch: got %f, want %f", i, result[i], samples[i])
			}
		}
	})
	t.Run("should downsample from 250000 to 16000", func(t *testing.T) {
		// 250000 / 16000 = 15.625 ratio
		samples := make([]float64, 2500) // 0.01 seconds at 250kHz
		for i := range samples {
			samples[i] = float64(i) / float64(len(samples))
		}
		result := ResampleRate(samples, 250000, 16000)
		expectedLen := 160 // 0.01 seconds at 16kHz
		if len(result) != expectedLen {
			t.Errorf("length mismatch: got %d, want %d", len(result), expectedLen)
		}
	})
	t.Run("should downsample from 44100 to 16000", func(t *testing.T) {
		// 44100 / 16000 = 2.75625 ratio
		samples := make([]float64, 441) // 0.01 seconds at 44.1kHz
		for i := range samples {
			samples[i] = float64(i) / float64(len(samples))
		}
		result := ResampleRate(samples, 44100, 16000)
		expectedLen := 160 // 0.01 seconds at 16kHz
		if len(result) != expectedLen {
			t.Errorf("length mismatch: got %d, want %d", len(result), expectedLen)
		}
	})
	t.Run("should preserve signal shape", func(t *testing.T) {
		// Create a simple ramp signal
		samples := []float64{0.0, 0.25, 0.5, 0.75, 1.0}
		result := ResampleRate(samples, 50000, 16000)
		// Should still be a roughly increasing signal
		for i := 1; i < len(result); i++ {
			if result[i] < result[i-1]-0.1 {
				t.Errorf("signal not preserved: result[%d]=%f < result[%d]=%f", i, result[i], i-1, result[i-1])
			}
		}
	})
	t.Run("should handle empty samples", func(t *testing.T) {
		result := ResampleRate([]float64{}, 44100, 16000)
		if len(result) != 0 {
			t.Errorf("expected empty result, got %d samples", len(result))
		}
	})
}
func TestResample(t *testing.T) {
	t.Run("should return same samples for speed 1.0", func(t *testing.T) {
		samples := []float64{0.1, 0.2, 0.3, 0.4, 0.5}
		result := Resample(samples, 1.0)
		if len(result) != len(samples) {
			t.Errorf("length mismatch: got %d, want %d", len(result), len(samples))
		}
		for i := range samples {
			if result[i] != samples[i] {
				t.Errorf("sample %d mismatch: got %f, want %f", i, result[i], samples[i])
			}
		}
	})
	t.Run("should double samples for half speed", func(t *testing.T) {
		samples := []float64{0.0, 1.0, 0.0, -1.0, 0.0}
		result := Resample(samples, 0.5)
		// Half speed = 2x more samples
		expectedLen := len(samples) * 2
		if len(result) != expectedLen {
			t.Errorf("length mismatch: got %d, want %d", len(result), expectedLen)
		}
	})
	t.Run("should halve samples for double speed", func(t *testing.T) {
		samples := []float64{0.0, 0.5, 1.0, 0.5, 0.0, -0.5, -1.0, -0.5, 0.0}
		result := Resample(samples, 2.0)
		// Double speed = half the samples
		expectedLen := len(samples) / 2
		if len(result) != expectedLen {
			t.Errorf("length mismatch: got %d, want %d", len(result), expectedLen)
		}
	})
	t.Run("should use linear interpolation", func(t *testing.T) {
		// With samples [0, 1], half-speed should interpolate to [0, 0.5, 1]
		samples := []float64{0.0, 1.0}
		result := Resample(samples, 0.5)
		// Expected: 4 samples (2 / 0.5 = 4)
		if len(result) != 4 {
			t.Errorf("length mismatch: got %d, want 4", len(result))
		}
		// Check interpolation: index 1 should be ~0.5 (midpoint)
		expected := 0.5
		if math.Abs(result[1]-expected) > 0.01 {
			t.Errorf("interpolated value mismatch: got %f, want ~%f", result[1], expected)
		}
	})
	t.Run("should handle empty samples", func(t *testing.T) {
		result := Resample([]float64{}, 0.5)
		if len(result) != 0 {
			t.Errorf("expected empty result, got %d samples", len(result))
		}
	})
	t.Run("should handle single sample", func(t *testing.T) {
		samples := []float64{0.5}
		result := Resample(samples, 0.5)
		// 1 / 0.5 = 2 samples
		if len(result) != 2 {
			t.Errorf("length mismatch: got %d, want 2", len(result))
		}
	})
}
func TestResampleQuality(t *testing.T) {
	t.Run("should preserve zero crossings", func(t *testing.T) {
		// Sine wave: should have zero crossings at multiples of pi
		sampleRate := 1000
		samples := make([]float64, sampleRate)
		for i := range samples {
			samples[i] = math.Sin(2 * math.Pi * float64(i) / float64(sampleRate))
		}
		// Resample to half speed
		result := Resample(samples, 0.5)
		// First sample should still be ~0 (sine at 0)
		if math.Abs(result[0]) > 0.01 {
			t.Errorf("first sample not near zero: got %f", result[0])
		}
		// Peak should still be ~1.0 (sine max)
		peakFound := false
		for _, s := range result {
			if math.Abs(s-1.0) < 0.1 {
				peakFound = true
				break
			}
		}
		if !peakFound {
			t.Error("peak not preserved in resampled signal")
		}
	})
}

package utils
// ResampleRate converts samples from one sample rate to another using linear interpolation.
// This is used to downsample high sample rate audio for spectrogram visualization.
// fromRate: original sample rate (e.g., 250000)
// toRate: target sample rate (e.g., 16000)
func ResampleRate(samples []float64, fromRate, toRate int) []float64 {
	if fromRate == toRate || len(samples) == 0 {
		return samples
	}
	// Calculate ratio: toRate/fromRate (e.g., 16000/250000 = 0.064)
	ratio := float64(toRate) / float64(fromRate)
	newLen := int(float64(len(samples)) * ratio)
	if newLen <= 0 {
		return samples
	}
	result := make([]float64, newLen)
	for i := range newLen {
		// Source index in original samples (floating point)
		srcIdx := float64(i) / ratio
		idx0 := int(srcIdx)
		idx1 := idx0 + 1
		// Clamp to valid range
		if idx0 >= len(samples) {
			idx0 = len(samples) - 1
		}
		if idx1 >= len(samples) {
			idx1 = len(samples) - 1
		}
		// Linear interpolation between adjacent samples
		frac := srcIdx - float64(idx0)
		result[i] = samples[idx0]*(1-frac) + samples[idx1]*frac
	}
	return result
}
// Resample changes playback speed using linear interpolation.
// speed > 1.0 = faster (fewer samples), speed < 1.0 = slower (more samples).
// For half-speed playback, use speed=0.5 which doubles the sample count.
func Resample(samples []float64, speed float64) []float64 {
	if speed == 1.0 || len(samples) == 0 {
		return samples
	}
	// Calculate new length: slower speed = more samples
	newLen := int(float64(len(samples)) / speed)
	if newLen <= 0 {
		return samples
	}
	result := make([]float64, newLen)
	for i := range newLen {
		// Source index in original samples (floating point)
		srcIdx := float64(i) * speed
		idx0 := int(srcIdx)
		idx1 := idx0 + 1
		// Clamp to valid range
		if idx0 >= len(samples) {
			idx0 = len(samples) - 1
		}
		if idx1 >= len(samples) {
			idx1 = len(samples) - 1
		}
		// Linear interpolation between adjacent samples
		frac := srcIdx - float64(idx0)
		result[i] = samples[idx0]*(1-frac) + samples[idx1]*frac
	}
	return result
}

package utils
import (
	"testing"
)
func TestStripMountPoint(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		// macOS
		{"macOS volume", "/Volumes/ExternalDrive/Audio", "ExternalDrive/Audio"},
		{"macOS root volume", "/Volumes/Drive", "Drive"},
		// Linux /media/ with username
		{"Linux media mount", "/media/david/USB-Drive/Audio", "USB-Drive/Audio"},
		{"Linux media different user", "/media/john/Backup/Audio", "Backup/Audio"},
		{"Linux media Pomona", "/media/david/Pomona-4/Pomona/A05/2025-11-08", "Pomona-4/Pomona/A05/2025-11-08"},
		// Linux /mnt/
		{"Linux mnt mount", "/mnt/storage/Audio", "storage/Audio"},
		// No mount point
		{"Absolute no mount", "/home/user/Audio", "/home/user/Audio"},
		{"Relative path", "./relative/path", "relative/path"},
		// Edge cases
		{"Root", "/", "/"},
		{"Empty", "", "."},
		{"Volumes only", "/Volumes/", "."},
		{"Media with user only", "/media/david/", "."},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := StripMountPoint(tt.input)
			if result != tt.expected {
				t.Errorf("StripMountPoint(%q) = %q, want %q", tt.input, result, tt.expected)
			}
		})
	}
}
func TestNormalizeFolderPath(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		// Full workflow
		{"Linux media path", "/media/david/Pomona-4/Pomona/A05/2025-11-08/", "Pomona-4/Pomona/A05/2025-11-08"},
		{"macOS volumes path", "/Volumes/Drive/Audio/Recordings/", "Drive/Audio/Recordings"},
		{"Linux mnt path", "/mnt/storage/Audio/Files/", "storage/Audio/Files"},
		// Trailing slashes handled
		{"With trailing slash", "/media/david/USB/Audio/", "USB/Audio"},
		{"Without trailing slash", "/media/david/USB/Audio", "USB/Audio"},
		// Multiple levels
		{"Deep nested path", "/media/david/Pomona-4/Level1/Level2/Level3/", "Pomona-4/Level1/Level2/Level3"},
		// Edge cases
		{"File at mount root", "/media/david/", "."},
		{"Volumes with drive only", "/Volumes/Drive/", "Drive"},
		{"Volumes drive no trailing slash", "/Volumes/Drive", "Drive"},
		{"Root", "/", ""},
		{"Empty", "", "."},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := NormalizeFolderPath(tt.input)
			if result != tt.expected {
				t.Errorf("NormalizeFolderPath(%q) = %q, want %q", tt.input, result, tt.expected)
			}
		})
	}
}

package utils
import (
	"path/filepath"
	"runtime"
	"strings"
)
// StripMountPoint removes OS-specific mount point prefixes from a path
func StripMountPoint(absPath string) string {
	// Clean path first
	absPath = filepath.Clean(absPath)
	// Handle Windows drive letters
	if runtime.GOOS == "windows" {
		volumeName := filepath.VolumeName(absPath)
		if volumeName != "" {
			// Remove "C:\" and return rest
			return strings.TrimPrefix(absPath, volumeName+string(filepath.Separator))
		}
	}
	// Handle Unix-like mount points
	switch {
	case absPath == "/Volumes":
		// Exact match to mount point root
		return "."
	case strings.HasPrefix(absPath, "/Volumes/"):
		// macOS external volumes: /Volumes/Drive/... → Drive/...
		return strings.TrimPrefix(absPath, "/Volumes/")
	case strings.HasPrefix(absPath, "/media/"):
		// Linux user mounts: /media/username/Drive/... → Drive/...
		// Strip /media/ and the username directory
		pathAfterMedia := strings.TrimPrefix(absPath, "/media/")
		parts := strings.SplitN(pathAfterMedia, string(filepath.Separator), 2)
		if len(parts) > 1 {
			return parts[1] // Return everything after username
		}
		// Just username, no subdirectory (e.g., /media/david)
		return "."
	case strings.HasPrefix(absPath, "/mnt/"):
		// Linux system mounts: /mnt/storage/... → storage/...
		return strings.TrimPrefix(absPath, "/mnt/")
	}
	// No known mount point detected, return as-is
	return absPath
}
// NormalizeFolderPath strips mount points and cleans up a folder path
// Unlike a file path normalization, this expects a directory path
func NormalizeFolderPath(folderPath string) string {
	// Clean the path
	folderPath = filepath.Clean(folderPath)
	// Strip mount point
	relativePath := StripMountPoint(folderPath)
	// Clean up leading/trailing slashes
	relativePath = strings.Trim(relativePath, string(filepath.Separator))
	return relativePath
}

package utils
import (
	"regexp"
	"testing"
)
func TestGenerateShortID(t *testing.T) {
	// Test that it generates a 12-character ID
	id, err := GenerateShortID()
	if err != nil {
		t.Fatalf("GenerateShortID() error = %v", err)
	}
	if len(id) != 12 {
		t.Errorf("GenerateShortID() length = %d, want 12", len(id))
	}
	// Verify it only contains valid alphabet characters
	// Default nanoid alphabet uses A-Za-z0-9_- symbols (64 characters)
	validPattern := regexp.MustCompile(`^[0-9A-Za-z_-]{12}$`)
	if !validPattern.MatchString(id) {
		t.Errorf("GenerateShortID() = %q, contains invalid characters", id)
	}
	// Test uniqueness - generate multiple IDs and check they're different
	ids := make(map[string]bool)
	for i := range 100 {
		id, err := GenerateShortID()
		if err != nil {
			t.Fatalf("GenerateShortID() iteration %d error = %v", i, err)
		}
		if ids[id] {
			t.Errorf("GenerateShortID() produced duplicate: %q", id)
		}
		ids[id] = true
	}
}
func TestGenerateLongID(t *testing.T) {
	// Test that it generates a 21-character ID
	id, err := GenerateLongID()
	if err != nil {
		t.Fatalf("GenerateLongID() error = %v", err)
	}
	if len(id) != 21 {
		t.Errorf("GenerateLongID() length = %d, want 21", len(id))
	}
	// Verify it only contains valid alphabet characters
	// Default nanoid alphabet uses A-Za-z0-9_- symbols (64 characters)
	validPattern := regexp.MustCompile(`^[0-9A-Za-z_-]{21}$`)
	if !validPattern.MatchString(id) {
		t.Errorf("GenerateLongID() = %q, contains invalid characters", id)
	}
	// Test uniqueness - generate multiple IDs and check they're different
	ids := make(map[string]bool)
	for i := range 100 {
		id, err := GenerateLongID()
		if err != nil {
			t.Fatalf("GenerateLongID() iteration %d error = %v", i, err)
		}
		if ids[id] {
			t.Errorf("GenerateLongID() produced duplicate: %q", id)
		}
		ids[id] = true
	}
}
func TestIDsAreDifferent(t *testing.T) {
	// Verify that short and long IDs are different types
	shortID, err := GenerateShortID()
	if err != nil {
		t.Fatalf("GenerateShortID() error = %v", err)
	}
	longID, err := GenerateLongID()
	if err != nil {
		t.Fatalf("GenerateLongID() error = %v", err)
	}
	if len(shortID) == len(longID) {
		t.Error("Short and long IDs should have different lengths")
	}
	if len(shortID) != 12 {
		t.Errorf("Short ID length = %d, want 12", len(shortID))
	}
	if len(longID) != 21 {
		t.Errorf("Long ID length = %d, want 21", len(longID))
	}
}

package utils
import (
	gonanoid "github.com/matoous/go-nanoid/v2"
)
// GenerateShortID generates a 12-character nanoid using the full alphabet
// Used for: dataset_id, location_id, cluster_id, pattern_id
// Entropy: ~71 bits (62^12 ≈ 3.2×10^21 combinations)
func GenerateShortID() (string, error) {
	return gonanoid.New(12)
}
// GenerateLongID generates a 21-character nanoid using the full alphabet
// Used for: file_id, segment_id, label_id
// Entropy: ~125 bits (62^21 ≈ 2.7×10^37 combinations)
func GenerateLongID() (string, error) {
	return gonanoid.New(21)
}

package utils
import (
	"os"
	"path/filepath"
	"testing"
)
func TestLoadMappingFile(t *testing.T) {
	t.Run("valid mapping", func(t *testing.T) {
		content := `{
			"GSK": {"species": "Roroa", "calltypes": {"Male": "Male - Solo"}},
			"Don't Know": {"species": "Don't Know"}
		}`
		path := createTempFile(t, content)
		defer os.Remove(path)
		mapping, err := LoadMappingFile(path)
		if err != nil {
			t.Fatalf("expected no error, got: %v", err)
		}
		if len(mapping) != 2 {
			t.Errorf("expected 2 entries, got %d", len(mapping))
		}
		if mapping["GSK"].Species != "Roroa" {
			t.Errorf("expected GSK -> Roroa, got %s", mapping["GSK"].Species)
		}
		if mapping["GSK"].Calltypes["Male"] != "Male - Solo" {
			t.Errorf("expected GSK Male -> Male - Solo, got %s", mapping["GSK"].Calltypes["Male"])
		}
	})
	t.Run("invalid JSON", func(t *testing.T) {
		content := `{invalid json}`
		path := createTempFile(t, content)
		defer os.Remove(path)
		_, err := LoadMappingFile(path)
		if err == nil {
			t.Fatal("expected error for invalid JSON")
		}
	})
	t.Run("empty file", func(t *testing.T) {
		content := `{}`
		path := createTempFile(t, content)
		defer os.Remove(path)
		_, err := LoadMappingFile(path)
		if err == nil {
			t.Fatal("expected error for empty mapping")
		}
	})
	t.Run("missing species field", func(t *testing.T) {
		content := `{"GSK": {"calltypes": {"Male": "Male - Solo"}}}`
		path := createTempFile(t, content)
		defer os.Remove(path)
		_, err := LoadMappingFile(path)
		if err == nil {
			t.Fatal("expected error for missing species field")
		}
	})
	t.Run("empty species field", func(t *testing.T) {
		content := `{"GSK": {"species": ""}}`
		path := createTempFile(t, content)
		defer os.Remove(path)
		_, err := LoadMappingFile(path)
		if err == nil {
			t.Fatal("expected error for empty species field")
		}
	})
	t.Run("nonexistent file", func(t *testing.T) {
		_, err := LoadMappingFile("/nonexistent/path/mapping.json")
		if err == nil {
			t.Fatal("expected error for nonexistent file")
		}
	})
}
func TestGetDBSpecies(t *testing.T) {
	mapping := MappingFile{
		"GSK": {Species: "Roroa"},
		"K-M": {Species: "Kiwi"},
	}
	t.Run("found", func(t *testing.T) {
		species, ok := mapping.GetDBSpecies("GSK")
		if !ok {
			t.Fatal("expected to find GSK")
		}
		if species != "Roroa" {
			t.Errorf("expected Roroa, got %s", species)
		}
	})
	t.Run("not found", func(t *testing.T) {
		_, ok := mapping.GetDBSpecies("UNKNOWN")
		if ok {
			t.Fatal("expected not to find UNKNOWN")
		}
	})
}
func TestGetDBCalltype(t *testing.T) {
	mapping := MappingFile{
		"GSK": {
			Species: "Roroa",
			Calltypes: map[string]string{
				"Male":   "Male - Solo",
				"Female": "Female - Solo",
			},
		},
		"K-M": {Species: "Kiwi"}, // no calltype mapping
	}
	t.Run("with mapping", func(t *testing.T) {
		ct := mapping.GetDBCalltype("GSK", "Male")
		if ct != "Male - Solo" {
			t.Errorf("expected 'Male - Solo', got %s", ct)
		}
	})
	t.Run("without mapping - passthrough", func(t *testing.T) {
		ct := mapping.GetDBCalltype("GSK", "Unknown")
		if ct != "Unknown" {
			t.Errorf("expected passthrough 'Unknown', got %s", ct)
		}
	})
	t.Run("species not in mapping - passthrough", func(t *testing.T) {
		ct := mapping.GetDBCalltype("UNKNOWN", "Male")
		if ct != "Male" {
			t.Errorf("expected passthrough 'Male', got %s", ct)
		}
	})
	t.Run("species without calltypes - passthrough", func(t *testing.T) {
		ct := mapping.GetDBCalltype("K-M", "Male")
		if ct != "Male" {
			t.Errorf("expected passthrough 'Male', got %s", ct)
		}
	})
}
func TestMappingValidationResult(t *testing.T) {
	t.Run("HasErrors - no errors", func(t *testing.T) {
		r := MappingValidationResult{}
		if r.HasErrors() {
			t.Error("expected no errors")
		}
	})
	t.Run("HasErrors - missing species", func(t *testing.T) {
		r := MappingValidationResult{MissingSpecies: []string{"UNKNOWN"}}
		if !r.HasErrors() {
			t.Error("expected errors")
		}
	})
	t.Run("HasErrors - missing DB species", func(t *testing.T) {
		r := MappingValidationResult{MissingDBSpecies: []string{"Phantom"}}
		if !r.HasErrors() {
			t.Error("expected errors")
		}
	})
	t.Run("HasErrors - missing calltypes", func(t *testing.T) {
		r := MappingValidationResult{MissingCalltypes: map[string]string{"GSK/Male": "Roroa/Male - Solo"}}
		if !r.HasErrors() {
			t.Error("expected errors")
		}
	})
	t.Run("Error - all error types", func(t *testing.T) {
		r := MappingValidationResult{
			MissingSpecies:   []string{"UNKNOWN"},
			MissingDBSpecies: []string{"Phantom"},
			MissingCalltypes: map[string]string{"GSK/Male": "Roroa/Male - Solo"},
		}
		errStr := r.Error()
		if errStr == "" {
			t.Error("expected non-empty error string")
		}
		// Check all parts are present
		if !containsSubstring(errStr, "UNKNOWN") {
			t.Error("error string should contain MISSING species")
		}
		if !containsSubstring(errStr, "Phantom") {
			t.Error("error string should contain missing DB species")
		}
		if !containsSubstring(errStr, "GSK/Male") {
			t.Error("error string should contain missing calltype")
		}
	})
}
// Helper functions
func createTempFile(t *testing.T, content string) string {
	t.Helper()
	tmpDir := t.TempDir()
	path := filepath.Join(tmpDir, "mapping.json")
	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
		t.Fatalf("failed to create temp file: %v", err)
	}
	return path
}
func containsSubstring(s, substr string) bool {
	return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsSubstringHelper(s, substr))
}
func containsSubstringHelper(s, substr string) bool {
	for i := 0; i <= len(s)-len(substr); i++ {
		if s[i:i+len(substr)] == substr {
			return true
		}
	}
	return false
}

package utils
import (
	"database/sql"
	"encoding/json"
	"fmt"
	"os"
	"sort"
	"strings"
)
// SpeciesMapping maps .data species/calltype names to DB labels
type SpeciesMapping struct {
	Species   string            `json:"species"`
	Calltypes map[string]string `json:"calltypes,omitempty"`
}
// MappingFile represents the complete mapping file structure
// Key is the .data file species name
type MappingFile map[string]SpeciesMapping
// LoadMappingFile loads and parses a mapping JSON file
func LoadMappingFile(path string) (MappingFile, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		return nil, fmt.Errorf("failed to read mapping file: %w", err)
	}
	var mapping MappingFile
	if err := json.Unmarshal(data, &mapping); err != nil {
		return nil, fmt.Errorf("failed to parse mapping JSON: %w", err)
	}
	// Validate non-empty
	if len(mapping) == 0 {
		return nil, fmt.Errorf("mapping file is empty")
	}
	// Validate each entry has species
	for dataSpecies, sm := range mapping {
		if sm.Species == "" {
			return nil, fmt.Errorf("mapping entry '%s' has empty species field", dataSpecies)
		}
	}
	return mapping, nil
}
// MappingValidationResult contains validation errors for a mapping
type MappingValidationResult struct {
	MissingSpecies   []string          // .data species not in mapping
	MissingDBSpecies []string          // mapped species not in DB
	MissingCalltypes map[string]string // "dataSpecies/dataCalltype" -> "dbSpecies/dbCalltype"
}
// HasErrors returns true if any validation errors exist
func (r MappingValidationResult) HasErrors() bool {
	return len(r.MissingSpecies) > 0 ||
		len(r.MissingDBSpecies) > 0 ||
		len(r.MissingCalltypes) > 0
}
// Error returns a formatted error message
func (r MappingValidationResult) Error() string {
	var parts []string
	if len(r.MissingSpecies) > 0 {
		parts = append(parts, fmt.Sprintf("species in .data but not in mapping: [%s]",
			strings.Join(r.MissingSpecies, ", ")))
	}
	if len(r.MissingDBSpecies) > 0 {
		parts = append(parts, fmt.Sprintf("mapped species not found in DB: [%s]",
			strings.Join(r.MissingDBSpecies, ", ")))
	}
	if len(r.MissingCalltypes) > 0 {
		var ctErrors []string
		for k, v := range r.MissingCalltypes {
			ctErrors = append(ctErrors, fmt.Sprintf("%s->%s", k, v))
		}
		sort.Strings(ctErrors)
		parts = append(parts, fmt.Sprintf("calltypes not found in DB: [%s]",
			strings.Join(ctErrors, ", ")))
	}
	return strings.Join(parts, "; ")
}
// ValidateMappingAgainstDB validates that all mapped species and calltypes exist in the database
// Also validates that the mapping covers all species/calltypes found in .data files
func ValidateMappingAgainstDB(
	db *sql.DB,
	mapping MappingFile,
	dataSpeciesSet map[string]bool,
	dataCalltypes map[string]map[string]bool, // species -> calltype -> true
) (MappingValidationResult, error) {
	result := MappingValidationResult{
		MissingSpecies:   make([]string, 0),
		MissingDBSpecies: make([]string, 0),
		MissingCalltypes: make(map[string]string),
	}
	// Check all .data species are in mapping
	for species := range dataSpeciesSet {
		if _, exists := mapping[species]; !exists {
			result.MissingSpecies = append(result.MissingSpecies, species)
		}
	}
	sort.Strings(result.MissingSpecies)
	// Collect all mapped species and calltypes
	mappedSpeciesSet := make(map[string]bool)
	mappedCalltypes := make(map[string]map[string]string) // dbSpecies -> dbCalltype -> dataCalltype
	for _, sm := range mapping {
		mappedSpeciesSet[sm.Species] = true
		// Track calltype mappings
		if len(sm.Calltypes) > 0 {
			if mappedCalltypes[sm.Species] == nil {
				mappedCalltypes[sm.Species] = make(map[string]string)
			}
			for dataCT, dbCT := range sm.Calltypes {
				mappedCalltypes[sm.Species][dbCT] = dataCT
			}
		}
	}
	// Also collect unmapped calltypes (where .data calltype = DB calltype)
	for dataSpecies, ctSet := range dataCalltypes {
		sm, exists := mapping[dataSpecies]
		if !exists {
			continue // Already reported as missing species
		}
		dbSpecies := sm.Species
		for dataCT := range ctSet {
			// If no explicit mapping, assume dataCT == dbCT
			dbCT := dataCT
			if sm.Calltypes != nil {
				if mapped, ok := sm.Calltypes[dataCT]; ok {
					dbCT = mapped
				}
			}
			if mappedCalltypes[dbSpecies] == nil {
				mappedCalltypes[dbSpecies] = make(map[string]string)
			}
			mappedCalltypes[dbSpecies][dbCT] = dataCT
		}
	}
	// Validate species exist in DB
	speciesLabels := make([]string, 0, len(mappedSpeciesSet))
	for s := range mappedSpeciesSet {
		speciesLabels = append(speciesLabels, s)
	}
	sort.Strings(speciesLabels)
	if len(speciesLabels) > 0 {
		query := `SELECT label FROM species WHERE label IN (` + Placeholders(len(speciesLabels)) + `) AND active = true`
		args := make([]any, len(speciesLabels))
		for i, s := range speciesLabels {
			args[i] = s
		}
		rows, err := db.Query(query, args...)
		if err != nil {
			return result, fmt.Errorf("failed to query species: %w", err)
		}
		defer rows.Close()
		foundSpecies := make(map[string]bool)
		for rows.Next() {
			var label string
			if err := rows.Scan(&label); err == nil {
				foundSpecies[label] = true
			}
		}
		for _, s := range speciesLabels {
			if !foundSpecies[s] {
				result.MissingDBSpecies = append(result.MissingDBSpecies, s)
			}
		}
	}
	// Validate calltypes exist in DB
	for dbSpecies, ctMap := range mappedCalltypes {
		if len(ctMap) == 0 {
			continue
		}
		ctLabels := make([]string, 0, len(ctMap))
		for dbCT := range ctMap {
			ctLabels = append(ctLabels, dbCT)
		}
		sort.Strings(ctLabels)
		query := `
			SELECT ct.label
			FROM call_type ct
			JOIN species s ON ct.species_id = s.id
			WHERE s.label = ? AND ct.label IN (` + Placeholders(len(ctLabels)) + `) AND ct.active = true`
		args := make([]any, 1+len(ctLabels))
		args[0] = dbSpecies
		for i, ct := range ctLabels {
			args[1+i] = ct
		}
		rows, err := db.Query(query, args...)
		if err != nil {
			return result, fmt.Errorf("failed to query calltypes for species %s: %w", dbSpecies, err)
		}
		defer rows.Close()
		foundCT := make(map[string]bool)
		for rows.Next() {
			var label string
			if err := rows.Scan(&label); err == nil {
				foundCT[label] = true
			}
		}
		for dbCT, dataCT := range ctMap {
			if !foundCT[dbCT] {
				key := fmt.Sprintf("%s/%s", dbSpecies, dataCT)
				value := fmt.Sprintf("%s/%s", dbSpecies, dbCT)
				result.MissingCalltypes[key] = value
			}
		}
	}
	return result, nil
}
// GetDBSpecies returns the DB species label for a .data species
func (m MappingFile) GetDBSpecies(dataSpecies string) (string, bool) {
	sm, exists := m[dataSpecies]
	if !exists {
		return "", false
	}
	return sm.Species, true
}
// GetDBCalltype returns the DB calltype label for a .data species/calltype
// Returns the dataCalltype unchanged if no mapping exists
func (m MappingFile) GetDBCalltype(dataSpecies, dataCalltype string) string {
	sm, exists := m[dataSpecies]
	if !exists || sm.Calltypes == nil {
		return dataCalltype
	}
	if dbCT, ok := sm.Calltypes[dataCalltype]; ok {
		return dbCT
	}
	return dataCalltype
}
// Mapping sentinels: special values for the SpeciesMapping.Species field.
//
// MappingNegative marks a .data species as "confirmed empty" (Noise-equivalent):
// segments matching this name are treated as negative evidence — clips overlapping
// them emit an all-zero row when no positive species also overlaps.
//
// MappingIgnore marks a .data species as "ignored entirely": segments matching
// this name neither label clips nor block them.
const (
	MappingNegative = "__NEGATIVE__"
	MappingIgnore   = "__IGNORE__"
)
// MappingKind describes how a .data species should be treated.
type MappingKind int
const (
	MappingReal MappingKind = iota
	MappingNeg
	MappingIgn
)
// Classify returns the canonical class name and kind for a .data species.
// ok is false if dataSpecies is not present in the mapping.
// For MappingNeg and MappingIgn the canonical string is empty.
func (m MappingFile) Classify(dataSpecies string) (canonical string, kind MappingKind, ok bool) {
	sm, exists := m[dataSpecies]
	if !exists {
		return "", MappingReal, false
	}
	switch sm.Species {
	case MappingNegative:
		return "", MappingNeg, true
	case MappingIgnore:
		return "", MappingIgn, true
	default:
		return sm.Species, MappingReal, true
	}
}
// ValidateCoversSpecies returns the sorted list of species in speciesSet that
// are missing from the mapping. Empty result means full coverage.
func (m MappingFile) ValidateCoversSpecies(speciesSet map[string]bool) []string {
	missing := make([]string, 0)
	for s := range speciesSet {
		if _, exists := m[s]; !exists {
			missing = append(missing, s)
		}
	}
	sort.Strings(missing)
	return missing
}
// Classes returns the sorted unique non-sentinel canonical class names from the mapping.
// Used to build the CSV column header for clip-labels.
func (m MappingFile) Classes() []string {
	set := make(map[string]bool)
	for _, sm := range m {
		switch sm.Species {
		case MappingNegative, MappingIgnore, "":
			continue
		default:
			set[sm.Species] = true
		}
	}
	out := make([]string, 0, len(set))
	for s := range set {
		out = append(out, s)
	}
	sort.Strings(out)
	return out
}
// placeholders generates SQL placeholder string for IN clauses
func Placeholders(n int) string {
	if n == 0 {
		return ""
	}
	ph := make([]string, n)
	for i := range ph {
		ph[i] = "?"
	}
	return strings.Join(ph, ", ")
}

package utils
import (
	"testing"
)
func TestParseFilenameTimestamps(t *testing.T) {
	t.Run("should parse YYMMDD format (test case a)", func(t *testing.T) {
		filenames := []string{
			"201012_123456.wav",
			"201014_123456.WAV",
			"201217_123456.wav",
			"211122_123456.WAV",
		}
		results, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		if len(results) != 4 {
			t.Fatalf("Expected 4 results, got %d", len(results))
		}
		// Year 20 should be interpreted as 2020 (less variance than days)
		if results[0].Timestamp.Year() != 2020 {
			t.Errorf("Year incorrect for file 0: got %d, want 2020", results[0].Timestamp.Year())
		}
		if results[0].Timestamp.Month() != 10 { // October
			t.Errorf("Month incorrect for file 0: got %d, want 10", results[0].Timestamp.Month())
		}
		if results[0].Timestamp.Day() != 12 {
			t.Errorf("Day incorrect for file 0: got %d, want 12", results[0].Timestamp.Day())
		}
		if results[0].Timestamp.Hour() != 12 {
			t.Errorf("Hour incorrect for file 0: got %d, want 12", results[0].Timestamp.Hour())
		}
		if results[0].Timestamp.Minute() != 34 {
			t.Errorf("Minute incorrect for file 0: got %d, want 34", results[0].Timestamp.Minute())
		}
		if results[0].Timestamp.Second() != 56 {
			t.Errorf("Second incorrect for file 0: got %d, want 56", results[0].Timestamp.Second())
		}
		if results[3].Timestamp.Year() != 2021 {
			t.Errorf("Year incorrect for file 3: got %d, want 2021", results[3].Timestamp.Year())
		}
		if results[3].Timestamp.Month() != 11 { // November
			t.Errorf("Month incorrect for file 3: got %d, want 11", results[3].Timestamp.Month())
		}
		if results[3].Timestamp.Day() != 22 {
			t.Errorf("Day incorrect for file 3: got %d, want 22", results[3].Timestamp.Day())
		}
	})
	t.Run("should parse DDMMYY format (test case b)", func(t *testing.T) {
		filenames := []string{
			"121020_123456.WAV",
			"141020_123456.wav",
			"171220_123456.WAV",
			"221121_123456.wav",
		}
		results, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		if len(results) != 4 {
			t.Fatalf("Expected 4 results, got %d", len(results))
		}
		// More variance in first two digits (12,14,17,22) than last two (20,20,20,21)
		// So DDMMYY format: day=first, month=middle, year=last+2000
		if results[0].Timestamp.Day() != 12 {
			t.Errorf("Day incorrect for file 0: got %d, want 12", results[0].Timestamp.Day())
		}
		if results[0].Timestamp.Month() != 10 { // October
			t.Errorf("Month incorrect for file 0: got %d, want 10", results[0].Timestamp.Month())
		}
		if results[0].Timestamp.Year() != 2020 {
			t.Errorf("Year incorrect for file 0: got %d, want 2020", results[0].Timestamp.Year())
		}
		if results[2].Timestamp.Day() != 17 {
			t.Errorf("Day incorrect for file 2: got %d, want 17", results[2].Timestamp.Day())
		}
		if results[2].Timestamp.Month() != 12 { // December
			t.Errorf("Month incorrect for file 2: got %d, want 12", results[2].Timestamp.Month())
		}
		if results[2].Timestamp.Year() != 2020 {
			t.Errorf("Year incorrect for file 2: got %d, want 2020", results[2].Timestamp.Year())
		}
	})
	t.Run("should parse YYYYMMDD format (test case c)", func(t *testing.T) {
		filenames := []string{
			"20230609_103000.WAV",
			"20241109_201504.wav",
		}
		results, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		if len(results) != 2 {
			t.Fatalf("Expected 2 results, got %d", len(results))
		}
		if results[0].Timestamp.Year() != 2023 {
			t.Errorf("Year incorrect: got %d, want 2023", results[0].Timestamp.Year())
		}
		if results[0].Timestamp.Month() != 6 { // June
			t.Errorf("Month incorrect: got %d, want 6", results[0].Timestamp.Month())
		}
		if results[0].Timestamp.Day() != 9 {
			t.Errorf("Day incorrect: got %d, want 9", results[0].Timestamp.Day())
		}
		if results[0].Timestamp.Hour() != 10 {
			t.Errorf("Hour incorrect: got %d, want 10", results[0].Timestamp.Hour())
		}
		if results[0].Timestamp.Minute() != 30 {
			t.Errorf("Minute incorrect: got %d, want 30", results[0].Timestamp.Minute())
		}
		if results[0].Timestamp.Second() != 0 {
			t.Errorf("Second incorrect: got %d, want 0", results[0].Timestamp.Second())
		}
		if results[1].Timestamp.Year() != 2024 {
			t.Errorf("Year incorrect: got %d, want 2024", results[1].Timestamp.Year())
		}
	})
	t.Run("should parse mixed 6-digit dates with variance detection (test case d)", func(t *testing.T) {
		filenames := []string{
			"120119_003002.wav",
			"180120_231502.wav",
			"170122_010005.wav",
			"010419_234502.WAV",
			"310320_231502.wav",
			"220824_231502.WAV",
			"240123_231502.wav",
		}
		results, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		if len(results) != 7 {
			t.Fatalf("Expected 7 results, got %d", len(results))
		}
		// First two digits: 12,18,17,01,31,22,24 (variance = high)
		// Last two digits: 19,20,22,19,20,24,23 (variance = lower)
		// Should be DDMMYY format
		if results[0].Timestamp.Day() != 12 {
			t.Errorf("Day incorrect: got %d, want 12", results[0].Timestamp.Day())
		}
		if results[0].Timestamp.Month() != 1 { // January
			t.Errorf("Month incorrect: got %d, want 1", results[0].Timestamp.Month())
		}
		if results[0].Timestamp.Year() != 2019 {
			t.Errorf("Year incorrect: got %d, want 2019", results[0].Timestamp.Year())
		}
		if results[4].Timestamp.Day() != 31 {
			t.Errorf("Day incorrect for file 4: got %d, want 31", results[4].Timestamp.Day())
		}
		if results[4].Timestamp.Month() != 3 { // March
			t.Errorf("Month incorrect for file 4: got %d, want 3", results[4].Timestamp.Month())
		}
	})
	t.Run("should throw error for empty filename array", func(t *testing.T) {
		_, err := ParseFilenameTimestamps([]string{})
		if err == nil {
			t.Error("Expected error for empty filename array")
		}
		if err != nil && err.Error() != "no filenames provided" {
			t.Logf("Error message: %v", err)
		}
	})
	t.Run("should throw error for filenames without date patterns", func(t *testing.T) {
		_, err := ParseFilenameTimestamps([]string{"invalid_filename.wav"})
		if err == nil {
			t.Error("Expected error for filenames without date patterns")
		}
	})
	t.Run("should parse filenames with prefixes (test case e)", func(t *testing.T) {
		filenames := []string{
			"XYZ123_7689_20230609_103000.WAV",
			"string 20241109_201504.wav",
		}
		results, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		if len(results) != 2 {
			t.Fatalf("Expected 2 results, got %d", len(results))
		}
		if results[0].Timestamp.Year() != 2023 {
			t.Errorf("Year incorrect: got %d, want 2023", results[0].Timestamp.Year())
		}
		if results[0].Timestamp.Month() != 6 { // June
			t.Errorf("Month incorrect: got %d, want 6", results[0].Timestamp.Month())
		}
		if results[0].Timestamp.Day() != 9 {
			t.Errorf("Day incorrect: got %d, want 9", results[0].Timestamp.Day())
		}
		if results[0].Timestamp.Hour() != 10 {
			t.Errorf("Hour incorrect: got %d, want 10", results[0].Timestamp.Hour())
		}
		if results[0].Timestamp.Minute() != 30 {
			t.Errorf("Minute incorrect: got %d, want 30", results[0].Timestamp.Minute())
		}
		if results[0].Timestamp.Second() != 0 {
			t.Errorf("Second incorrect: got %d, want 0", results[0].Timestamp.Second())
		}
		if results[1].Timestamp.Year() != 2024 {
			t.Errorf("Year incorrect: got %d, want 2024", results[1].Timestamp.Year())
		}
		if results[1].Timestamp.Month() != 11 { // November
			t.Errorf("Month incorrect: got %d, want 11", results[1].Timestamp.Month())
		}
		if results[1].Timestamp.Day() != 9 {
			t.Errorf("Day incorrect: got %d, want 9", results[1].Timestamp.Day())
		}
		if results[1].Timestamp.Hour() != 20 {
			t.Errorf("Hour incorrect: got %d, want 20", results[1].Timestamp.Hour())
		}
		if results[1].Timestamp.Minute() != 15 {
			t.Errorf("Minute incorrect: got %d, want 15", results[1].Timestamp.Minute())
		}
		if results[1].Timestamp.Second() != 4 {
			t.Errorf("Second incorrect: got %d, want 4", results[1].Timestamp.Second())
		}
	})
	t.Run("should parse filenames with complex prefixes (test case f)", func(t *testing.T) {
		filenames := []string{
			"abcdefg__1234_180120_231502.wav",
			"string 120119_003002.wav",
			"ABCD EFG___170122_010005.wav",
			"BHD_1234 010419_234502.WAV",
			"cill xyz 310320_231502.wav",
			"220824_231502.WAV",
			"240123_231502.wav",
		}
		results, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		if len(results) != 7 {
			t.Fatalf("Expected 7 results, got %d", len(results))
		}
		// Same pattern as test case d - should be DDMMYY
		if results[0].Timestamp.Day() != 18 {
			t.Errorf("Day incorrect: got %d, want 18", results[0].Timestamp.Day())
		}
		if results[0].Timestamp.Month() != 1 { // January
			t.Errorf("Month incorrect: got %d, want 1", results[0].Timestamp.Month())
		}
		if results[0].Timestamp.Year() != 2020 {
			t.Errorf("Year incorrect: got %d, want 2020", results[0].Timestamp.Year())
		}
		if results[0].Timestamp.Hour() != 23 {
			t.Errorf("Hour incorrect: got %d, want 23", results[0].Timestamp.Hour())
		}
		if results[0].Timestamp.Minute() != 15 {
			t.Errorf("Minute incorrect: got %d, want 15", results[0].Timestamp.Minute())
		}
		if results[0].Timestamp.Second() != 2 {
			t.Errorf("Second incorrect: got %d, want 2", results[0].Timestamp.Second())
		}
		if results[1].Timestamp.Day() != 12 {
			t.Errorf("Day incorrect: got %d, want 12", results[1].Timestamp.Day())
		}
		if results[1].Timestamp.Month() != 1 { // January
			t.Errorf("Month incorrect: got %d, want 1", results[1].Timestamp.Month())
		}
		if results[1].Timestamp.Year() != 2019 {
			t.Errorf("Year incorrect: got %d, want 2019", results[1].Timestamp.Year())
		}
		if results[4].Timestamp.Day() != 31 {
			t.Errorf("Day incorrect: got %d, want 31", results[4].Timestamp.Day())
		}
		if results[4].Timestamp.Month() != 3 { // March
			t.Errorf("Month incorrect: got %d, want 3", results[4].Timestamp.Month())
		}
		if results[4].Timestamp.Year() != 2020 {
			t.Errorf("Year incorrect: got %d, want 2020", results[4].Timestamp.Year())
		}
	})
	t.Run("should throw error for mixed date formats", func(t *testing.T) {
		mixedFormats := []string{"201012_123456.wav", "20231012_123456.wav"} // 6-digit vs 8-digit
		_, err := ParseFilenameTimestamps(mixedFormats)
		if err == nil {
			t.Error("Expected error for mixed date formats")
		}
	})
	t.Run("should throw error for wrong length patterns", func(t *testing.T) {
		wrongLength := []string{"2010_123456.wav"} // 4 digits instead of 6 or 8
		_, err := ParseFilenameTimestamps(wrongLength)
		if err == nil {
			t.Error("Expected error for wrong length patterns")
		}
	})
	t.Run("should throw error when not enough files for 6-digit disambiguation", func(t *testing.T) {
		singleFile := []string{"120119_003002.wav"}
		_, err := ParseFilenameTimestamps(singleFile)
		if err == nil {
			t.Error("Expected error when not enough files for 6-digit disambiguation")
		}
	})
}
func TestApplyTimezoneOffset(t *testing.T) {
	t.Run("should apply UTC timezone correctly", func(t *testing.T) {
		filenames := []string{
			"201012_123456.wav",
			"201014_123456.WAV",
		}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		results, err := ApplyTimezoneOffset(parsed, "UTC")
		if err != nil {
			t.Fatalf("Failed to apply timezone: %v", err)
		}
		if len(results) != 2 {
			t.Fatalf("Expected 2 results, got %d", len(results))
		}
		// Check timezone offset is +00:00
		_, offset := results[0].Zone()
		if offset != 0 {
			t.Errorf("UTC offset should be 0, got %d", offset)
		}
	})
	t.Run("should use fixed offset for entire cluster spanning DST transition", func(t *testing.T) {
		// Test files spanning the Auckland DST transition in April 2021
		// DST ended on April 4, 2021 (UTC+13 -> UTC+12)
		filenames := []string{
			"20210401_120000.wav", // April 1st - DST still active (UTC+13)
			"20210410_120000.wav", // April 10th - DST ended (would be UTC+12 if DST applied)
			"20210420_120000.wav", // April 20th - Standard time (would be UTC+12 if DST applied)
		}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		results, err := ApplyTimezoneOffset(parsed, "Pacific/Auckland")
		if err != nil {
			t.Fatalf("Failed to apply timezone: %v", err)
		}
		if len(results) != 3 {
			t.Fatalf("Expected 3 results, got %d", len(results))
		}
		// All files should use the same offset (from April 1st - earliest file)
		offsets := make([]int, len(results))
		for i, r := range results {
			_, offset := r.Zone()
			offsets[i] = offset
		}
		// Check all offsets are the same
		firstOffset := offsets[0]
		for i, offset := range offsets {
			if offset != firstOffset {
				t.Errorf("File %d has different offset: got %d, want %d", i, offset, firstOffset)
			}
		}
		// The offset should be UTC+13 (from the earliest file: April 1st)
		expectedOffsetSeconds := 13 * 3600
		if firstOffset != expectedOffsetSeconds {
			t.Errorf("Offset incorrect: got %d seconds, want %d seconds (UTC+13)", firstOffset, expectedOffsetSeconds)
		}
		// Verify UTC conversion uses the fixed offset consistently
		// All files at 12:00 local should convert to the same UTC hour (with UTC+13 offset)
		// 12:00 Auckland time - 13 hours = 23:00 UTC previous day
		for i, utcTime := range results {
			utc := utcTime.UTC()
			if utc.Hour() != 23 {
				t.Errorf("File %d UTC hour incorrect: got %d, want 23", i, utc.Hour())
			}
		}
	})
	t.Run("should handle out-of-order filenames correctly", func(t *testing.T) {
		// Files not in chronological order - should still use earliest file for offset
		filenames := []string{
			"20210410_120000.wav", // April 10th (later)
			"20210401_120000.wav", // April 1st (earliest - should determine offset)
			"20210405_120000.wav", // April 5th (middle)
		}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		results, err := ApplyTimezoneOffset(parsed, "Pacific/Auckland")
		if err != nil {
			t.Fatalf("Failed to apply timezone: %v", err)
		}
		// All files should use UTC+13 offset (from April 1st, the earliest)
		for i, r := range results {
			_, offset := r.Zone()
			expectedOffset := 13 * 3600
			if offset != expectedOffset {
				t.Errorf("File %d offset incorrect: got %d, want %d", i, offset, expectedOffset)
			}
		}
		// Results should maintain original filename order
		if results[0].Day() != 10 {
			t.Errorf("Result 0 should be April 10th, got day %d", results[0].Day())
		}
		if results[1].Day() != 1 {
			t.Errorf("Result 1 should be April 1st, got day %d", results[1].Day())
		}
		if results[2].Day() != 5 {
			t.Errorf("Result 2 should be April 5th, got day %d", results[2].Day())
		}
	})
	t.Run("should apply fixed offset consistently across large time spans", func(t *testing.T) {
		// Test files spanning multiple months with different DST periods
		filenames := []string{
			"20210215_120000.wav", // February 15th (summer, UTC+13)
			"20210615_120000.wav", // June 15th (winter, would be UTC+12 if DST applied)
			"20210815_120000.wav", // August 15th (winter, would be UTC+12 if DST applied)
		}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		results, err := ApplyTimezoneOffset(parsed, "Pacific/Auckland")
		if err != nil {
			t.Fatalf("Failed to apply timezone: %v", err)
		}
		// All files should use the same offset from the earliest file (February)
		expectedOffset := 13 * 3600
		for i, r := range results {
			_, offset := r.Zone()
			if offset != expectedOffset {
				t.Errorf("File %d offset incorrect: got %d, want %d", i, offset, expectedOffset)
			}
		}
		// Verify UTC conversion is consistent with fixed offset
		for i, r := range results {
			utc := r.UTC()
			if utc.Hour() != 23 { // 12 - 13 = -1 hour (23:00 previous day)
				t.Errorf("File %d UTC hour incorrect: got %d, want 23", i, utc.Hour())
			}
		}
	})
	t.Run("should handle US DST transitions with fixed offset", func(t *testing.T) {
		// Test US spring DST transition (March 14, 2021)
		filenames := []string{
			"20210310_120000.wav", // March 10th - before DST (UTC-5)
			"20210320_120000.wav", // March 20th - after DST (would be UTC-4 if DST applied)
		}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		results, err := ApplyTimezoneOffset(parsed, "America/New_York")
		if err != nil {
			t.Fatalf("Failed to apply timezone: %v", err)
		}
		// All files should use the same offset from earliest file (March 10th)
		expectedOffset := -5 * 3600
		for i, r := range results {
			_, offset := r.Zone()
			if offset != expectedOffset {
				t.Errorf("File %d offset incorrect: got %d, want %d", i, offset, expectedOffset)
			}
		}
		// Verify UTC conversion uses fixed offset
		for i, r := range results {
			utc := r.UTC()
			if utc.Hour() != 17 { // 12 + 5 = 17
				t.Errorf("File %d UTC hour incorrect: got %d, want 17", i, utc.Hour())
			}
		}
	})
	t.Run("should handle empty timestamps array", func(t *testing.T) {
		_, err := ApplyTimezoneOffset([]FilenameTimestamp{}, "UTC")
		if err == nil {
			t.Error("Expected error for empty timestamps array")
		}
	})
	t.Run("should handle invalid timezone", func(t *testing.T) {
		filenames := []string{"20210401_120000.wav"}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		_, err = ApplyTimezoneOffset(parsed, "Invalid/Timezone")
		if err == nil {
			t.Error("Expected error for invalid timezone")
		}
	})
}
func TestHasTimestampFilename(t *testing.T) {
	testCases := []struct {
		filename string
		expected bool
	}{
		{"201012_123456.wav", true},
		{"20230609_103000.WAV", true},
		{"invalid_filename.wav", false},
		{"201012_123456.txt", false},
		{"201012.wav", false},
		{"_123456.wav", false},
		{"", false},
	}
	for _, tc := range testCases {
		t.Run(tc.filename, func(t *testing.T) {
			result := HasTimestampFilename(tc.filename)
			if result != tc.expected {
				t.Errorf("HasTimestampFilename(%q) = %v, want %v", tc.filename, result, tc.expected)
			}
		})
	}
}
func TestFilenameParserEdgeCases(t *testing.T) {
	t.Run("should handle case-insensitive file extensions", func(t *testing.T) {
		filenames := []string{
			"201012_123456.wav",
			"201014_123456.WAV",
			"201217_123456.Wav",
		}
		results, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		if len(results) != 3 {
			t.Errorf("Expected 3 results, got %d", len(results))
		}
	})
	t.Run("should validate invalid dates", func(t *testing.T) {
		// 32nd day doesn't exist - should be caught by validation
		filenames := []string{"20240132_120000.wav"}
		_, err := ParseFilenameTimestamps(filenames)
		if err == nil {
			t.Error("Expected error for invalid date (day 32)")
		}
	})
	t.Run("should validate invalid months", func(t *testing.T) {
		// 13th month doesn't exist
		filenames := []string{"20241301_120000.wav"}
		_, err := ParseFilenameTimestamps(filenames)
		if err == nil {
			t.Error("Expected error for invalid month (13)")
		}
	})
	t.Run("should handle February 29th in leap year", func(t *testing.T) {
		filenames := []string{"20240229_120000.wav"} // 2024 is a leap year
		results, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse leap year date: %v", err)
		}
		if results[0].Timestamp.Day() != 29 {
			t.Errorf("Expected day 29, got %d", results[0].Timestamp.Day())
		}
	})
	t.Run("should reject February 29th in non-leap year", func(t *testing.T) {
		filenames := []string{"20230229_120000.wav"} // 2023 is not a leap year
		_, err := ParseFilenameTimestamps(filenames)
		if err == nil {
			t.Error("Expected error for Feb 29th in non-leap year")
		}
	})
}
func TestUTCConversionCorrectness(t *testing.T) {
	t.Run("should convert Pacific/Auckland night recordings correctly to UTC", func(t *testing.T) {
		// Test a night recording: 21:00 (9 PM) Pacific/Auckland
		// In May 2021, Pacific/Auckland is UTC+12 (standard time)
		// So 21:00 Pacific/Auckland should become 09:00 UTC same day
		filenames := []string{"20210505_210000.wav"}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		results, err := ApplyTimezoneOffset(parsed, "Pacific/Auckland")
		if err != nil {
			t.Fatalf("Failed to apply timezone: %v", err)
		}
		utcDate := results[0].UTC()
		if utcDate.Year() != 2021 {
			t.Errorf("Year incorrect: got %d, want 2021", utcDate.Year())
		}
		if utcDate.Month() != 5 {
			t.Errorf("Month incorrect: got %d, want 5", utcDate.Month())
		}
		if utcDate.Day() != 5 {
			t.Errorf("Day incorrect: got %d, want 5 (same day)", utcDate.Day())
		}
		if utcDate.Hour() != 9 {
			t.Errorf("Hour incorrect: got %d, want 9 (21 - 12 = 9)", utcDate.Hour())
		}
	})
	t.Run("should convert day recordings correctly to UTC", func(t *testing.T) {
		// Test a day recording: 12:00 (noon) Pacific/Auckland
		// Should become 00:00 UTC same day (midnight)
		filenames := []string{"20210505_120000.wav"}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		results, err := ApplyTimezoneOffset(parsed, "Pacific/Auckland")
		if err != nil {
			t.Fatalf("Failed to apply timezone: %v", err)
		}
		utcDate := results[0].UTC()
		if utcDate.Hour() != 0 {
			t.Errorf("Hour incorrect: got %d, want 0 (12 - 12 = 0, midnight UTC)", utcDate.Hour())
		}
		if utcDate.Day() != 5 {
			t.Errorf("Day incorrect: got %d, want 5 (same day)", utcDate.Day())
		}
	})
	t.Run("should handle date rollover correctly", func(t *testing.T) {
		// Test early morning: 02:00 Pacific/Auckland
		// Should become 14:00 UTC previous day
		filenames := []string{"20210505_020000.wav"}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		results, err := ApplyTimezoneOffset(parsed, "Pacific/Auckland")
		if err != nil {
			t.Fatalf("Failed to apply timezone: %v", err)
		}
		utcDate := results[0].UTC()
		if utcDate.Day() != 4 {
			t.Errorf("Day incorrect: got %d, want 4 (previous day)", utcDate.Day())
		}
		if utcDate.Hour() != 14 {
			t.Errorf("Hour incorrect: got %d, want 14 (2 - 12 = -10, so previous day 14:00)", utcDate.Hour())
		}
	})
	t.Run("should convert correctly for negative offset timezone", func(t *testing.T) {
		// Test 15:00 (3 PM) New York in June (UTC-4 during DST)
		// Should become 19:00 UTC same day
		filenames := []string{"20210615_150000.wav"}
		parsed, err := ParseFilenameTimestamps(filenames)
		if err != nil {
			t.Fatalf("Failed to parse filenames: %v", err)
		}
		results, err := ApplyTimezoneOffset(parsed, "America/New_York")
		if err != nil {
			t.Fatalf("Failed to apply timezone: %v", err)
		}
		utcDate := results[0].UTC()
		if utcDate.Hour() != 19 {
			t.Errorf("Hour incorrect: got %d, want 19 (15 + 4 = 19)", utcDate.Hour())
		}
		if utcDate.Day() != 15 {
			t.Errorf("Day incorrect: got %d, want 15 (same day)", utcDate.Day())
		}
	})
}