pool

var (
	// RecordChannelPool for single record channels
	RecordChannelPool = NewChannelPool[*Record](10000)

	// BatchChannelPool for batch channels
	BatchChannelPool = NewChannelPool[[]*Record](100)

	// SmallRecordChannelPool for smaller buffers
	SmallRecordChannelPool = NewChannelPool[*Record](100)

	// ErrorChannelPool for error channels
	ErrorChannelPool = NewChannelPool[error](10)
)

var (
	// RecordPool provides optimized pooling for Record objects
	RecordPool = New(
		func() *Record {
			return &Record{
				Data: make(map[string]interface{}, 16),
			}
		},
		func(r *Record) {
			r.ID = ""
			r.Schema = nil
			r.RawData = nil

			for k := range r.Data {
				delete(r.Data, k)
			}
			if r.Metadata.Custom != nil {
				for k := range r.Metadata.Custom {
					delete(r.Metadata.Custom, k)
				}
			}
			if r.Metadata.Before != nil {
				for k := range r.Metadata.Before {
					delete(r.Metadata.Before, k)
				}
			}

			r.Metadata = RecordMetadata{}
		},
	)

	// MapPool for map[string]interface{} objects
	MapPool = New(
		func() map[string]interface{} {
			return make(map[string]interface{}, 16)
		},
		func(m map[string]interface{}) {
			for k := range m {
				delete(m, k)
			}
		},
	)

	// StringSlicePool for []string objects
	StringSlicePool = New(
		func() []string {
			return make([]string, 0, 32)
		},
		func(s []string) {
			for i := range s {
				s[i] = ""
			}
			s = s[:0]
		},
	)

	// ByteSlicePool for []byte objects
	ByteSlicePool = New(
		func() []byte {
			return make([]byte, 0, 1024)
		},
		func(b []byte) {
			b = b[:0]
		},
	)

	// IDBufferPool for ID generation
	IDBufferPool = New(
		func() []byte {
			return make([]byte, 0, 64)
		},
		func(b []byte) {
			b = b[:0]
		},
	)

	// BatchSlicePool for []*Record objects (used in pipeline batching)
	BatchSlicePool = New(
		func() []*Record {
			return make([]*Record, 0, 1000)
		},
		func(s []*Record) {

			for i := range s {
				s[i] = nil
			}
			s = s[:0]
		},
	)
)

var (
	// GlobalBufferPool for byte buffer pooling
	GlobalBufferPool = NewBufferPool()

	// GlobalArenaPool for arena allocation
	GlobalArenaPool = NewArenaPool(16*1024*1024, 10) // 16MB chunks, 10 arenas
)

var (
	// Pool for [][]string batches (CSV rows)
	StringBatchPool = &sync.Pool{
		New: func() interface{} {
			return make([][]string, 0, 5000)
		},
	}
)