// Path to test file relative to project root

	t.Logf("Go XXH64 hash:    %s", hash)
	t.Logf("Expected hash:    %s", expectedHash)

	// Verify hash is exactly 16 characters

	// Verify it's valid lowercase hexadecimal

	t.Logf("Hash format validated: %s", hash)

	// Create a temporary empty file

	// Create empty file

	// XXH64 hash of empty file with seed=0 is a known value

	// Compute hash multiple times

		t.Fatalf("ComputeXXH64() first call error = %v", err)

		t.Fatalf("first call error = %v", err)

		t.Fatalf("ComputeXXH64() second call error = %v", err)

		t.Fatalf("second call error = %v", err)

		t.Fatalf("ComputeXXH64() third call error = %v", err)

		t.Fatalf("third call error = %v", err)

	// All hashes should be identical (deterministic)

		t.Errorf("Hashes are not deterministic: %s, %s, %s", hash1, hash2, hash3)
	}
	t.Logf("Hash is deterministic: %s", hash1)
}
func TestComputeXXH64Streaming_Equivalence(t *testing.T) {
	wavFile := filepath.Join("..", "audio", "N14-2025-02-25-20241116_054500-685-703.wav")
	// Test that streaming version produces same result as memory version
	hashOriginal, err := ComputeXXH64(wavFile)
	if err != nil {
		t.Fatalf("ComputeXXH64() error = %v", err)
	}
	hashStreaming, err := ComputeXXH64Streaming(wavFile)
	if err != nil {
		t.Fatalf("ComputeXXH64Streaming() error = %v", err)
	}
	if hashOriginal != hashStreaming {
		t.Errorf("Streaming hash differs from original: original=%s streaming=%s", hashOriginal, hashStreaming)

		t.Errorf("hashes not deterministic: %s, %s, %s", hash1, hash2, hash3)

	t.Logf("Both versions produce identical hash: %s", hashOriginal)

func TestComputeXXH64Streaming_WAVFile(t *testing.T) {
	// Test streaming version with the same WAV file
	wavFile := filepath.Join("..", "audio", "N14-2025-02-25-20241116_054500-685-703.wav")
	hash, err := ComputeXXH64Streaming(wavFile)
	if err != nil {
		t.Fatalf("ComputeXXH64Streaming() error = %v", err)
	}
	expectedHash := "48dc1684324621de"
	if hash != expectedHash {
		t.Errorf("ComputeXXH64Streaming() = %v, want %v", hash, expectedHash)
	}
	t.Logf("Go XXH64 streaming hash: %s", hash)
	t.Logf("Expected hash: %s", expectedHash)
}

	// Create a small file that might produce a hash with leading zeros

	// Write a small amount of data

	// Verify hash is exactly 16 characters (with zero-padding if needed)

// Helper function to create an empty file

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)
	}
}

// Helper function to create a small test file

	// Write a single byte

// Buffer pools for reducing GC pressure during batch imports
var (
	// hashBufferPool stores 128KB buffers for hash streaming
	hashBufferPool = sync.Pool{
		New: func() any {
			buf := make([]byte, 128*1024)
			return &buf
		},
	}
)

var hashBufferPool = sync.Pool{
	New: func() any {
		buf := make([]byte, 128*1024)
		return &buf
	},
}

// getHashBuffer gets a 128KB buffer from the pool

// putHashBuffer returns a 128KB buffer to the pool

// ComputeXXH64 computes the XXH64 hash of a file with seed=0.

// ComputeXXH64 computes the XXH64 hash of a file using streaming I/O.
// Uses a constant ~128KB buffer regardless of file size.

// This version loads the entire file into memory - use ComputeXXH64Streaming for large files.
// ComputeXXH64 calculates XXH64 hash of file contents for duplicate detection

	// Read entire file as binary data
	data, err := os.ReadFile(filepath)
	if err != nil {
		return "", fmt.Errorf("failed to read file: %w", err)
	}
	// Compute XXH64 hash with default seed=0
	hashValue := xxhash.Sum64(data)
	// Format as 16-character lowercase hex with zero-padding
	// %016x = hex, lowercase, zero-padded to 16 chars
	return fmt.Sprintf("%016x", hashValue), nil
}
// ComputeXXH64Streaming computes the XXH64 hash of a file using streaming I/O.
// This uses constant memory (~128KB buffer) regardless of file size.
// Returns the hash as a 16-character lowercase hexadecimal string.
func ComputeXXH64Streaming(filepath string) (string, error) {

	// Get hash buffer from pool

	// Format as 16-character lowercase hex with zero-padding