"io"

	"sync"

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

// getHashBuffer gets a 128KB buffer from the pool
func getHashBuffer() *[]byte {
	return hashBufferPool.Get().(*[]byte)
}
// putHashBuffer returns a 128KB buffer to the pool
func putHashBuffer(buf *[]byte) {
	hashBufferPool.Put(buf)
}

// This version loads the entire file into memory - use ComputeXXH64Streaming for large files.

// 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) {
	file, err := os.Open(filepath)
	if err != nil {
		return "", fmt.Errorf("failed to open file: %w", err)
	}
	defer file.Close()
	// Get hash buffer from pool
	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)
	}
	// Format as 16-character lowercase hex with zero-padding
	return fmt.Sprintf("%016x", h.Sum64()), nil
}

	"sync"

	"github.com/cespare/xxhash/v2"

// Buffer pools for reducing GC pressure during batch imports
var (
	// headerBufferPool stores 200KB buffers for WAV header reading
	headerBufferPool = sync.Pool{
		New: func() interface{} {
			buf := make([]byte, 200*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)
}

	FileSize      int64     // File size in bytes

	fileSize := fileInfo.Size()
	// Get header buffer from pool
	headerBufPtr := getHeaderBuffer()
	defer putHeaderBuffer(headerBufPtr)
	headerBuf := (*headerBufPtr)[:cap(*headerBufPtr)]

	headerBuf := make([]byte, 200*1024)

	metadata, err := parseWAVFromBytes(headerBuf, filepath)

	metadata, err := parseWAVFromBytes(headerBuf)

	// Set file modification time

	// Set file modification time and size

	metadata.FileSize = fileSize

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

func parseWAVFromBytes(data []byte, filepath string) (*WAVMetadata, error) {

func parseWAVFromBytes(data []byte) (*WAVMetadata, error) {

		// Ensure we don't read beyond buffer
		if offset+chunkSize > len(data) {
			break
		}

			// Parse format chunk
			if chunkSize >= 16 {
				// audioFormat := binary.LittleEndian.Uint16(data[offset : offset+2])

			// Parse format chunk - need at least 16 bytes of data
			if chunkSize >= 16 && offset+16 <= len(data) {

				// byteRate := binary.LittleEndian.Uint32(data[offset+8 : offset+12])
				// blockAlign := binary.LittleEndian.Uint16(data[offset+12 : offset+14])

			// We only need the chunkSize from the header, not the actual audio data

			// Data chunk content is the audio data - we don't need to read it

			if chunkSize >= 4 {

			if chunkSize >= 4 && offset+chunkSize <= len(data) {

					// Parse INFO subchunks

	// If duration couldn't be calculated from data chunk, try from file size

	// Validate that we found essential chunks
	if metadata.SampleRate == 0 {
		return nil, fmt.Errorf("invalid WAV file: missing or corrupt fmt chunk")
	}

		if fileInfo, err := os.Stat(filepath); err == nil {
			// Estimate: fileSize - header (assume ~100 bytes header)
			dataSize := fileInfo.Size() - 100
			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(dataSize) / float64(bytesPerSecond)
				}
			}
		}

		return nil, fmt.Errorf("invalid WAV file: missing or corrupt data chunk")

	// Step 1: Extract WAV metadata from all files

	// Step 1: Extract WAV metadata and hash in single pass

		hash     string

		metadata, err := ParseWAVHeader(path)
		wavInfos[i] = wavInfo{path: path, metadata: metadata, err: err}

		metadata, hash, err := ParseWAVHeaderWithHash(path)
		wavInfos[i] = wavInfo{path: path, metadata: metadata, hash: hash, err: err}

		// Calculate hash
		hash, err := ComputeXXH64(info.path)
		if err != nil {
			errors = append(errors, FileImportError{
				FileName: filepath.Base(info.path),
				Error:    fmt.Sprintf("hash calculation failed: %v", err),
				Stage:    "hash",
			})
			continue
		}

			mothData, err = ParseAudioMothComment(info.metadata.Comment)
			if err == nil {

			var parseErr error
			mothData, parseErr = ParseAudioMothComment(info.metadata.Comment)
			if parseErr == nil {

					Error:    fmt.Sprintf("AudioMoth comment parsing failed: %v", err),

					Error:    fmt.Sprintf("AudioMoth comment parsing failed: %v", parseErr),

			Hash:           hash,

			Hash:           info.hash,