package stream

// Stream 提供类似Java Stream API的数据流操作
type Stream[T any] struct {
	data []T
}

// StreamOf 从切片创建Stream
func StreamOf[T any](slice []T) *Stream[T] {
	if slice == nil {
		return &Stream[T]{data: make([]T, 0)}
	}
	// 创建副本避免外部修改
	dataCopy := make([]T, len(slice))
	copy(dataCopy, slice)
	return &Stream[T]{
		data: dataCopy,
	}
}

// Filter 过滤元素
func (s *Stream[T]) Filter(predicate func(T) bool) *Stream[T] {
	if s == nil || predicate == nil {
		return &Stream[T]{data: make([]T, 0)}
	}
	var result []T
	for _, item := range s.data {
		if predicate(item) {
			result = append(result, item)
		}
	}
	return &Stream[T]{data: result}
}

// Map 转换元素
func (s *Stream[T]) Map(mapper func(T) T) *Stream[T] {
	if s == nil || mapper == nil {
		return &Stream[T]{data: make([]T, 0)}
	}
	result := make([]T, len(s.data))
	for i, item := range s.data {
		result[i] = mapper(item)
	}
	return &Stream[T]{data: result}
}

// ForEach 遍历元素
func (s *Stream[T]) ForEach(consumer func(T)) {
	if s == nil || consumer == nil {
		return
	}
	for _, item := range s.data {
		consumer(item)
	}
}

// Collect 收集结果到切片
func (s *Stream[T]) Collect() []T {
	if s == nil {
		return make([]T, 0)
	}
	// 返回副本避免外部修改
	result := make([]T, len(s.data))
	copy(result, s.data)
	return result
}

// Count 计数
func (s *Stream[T]) Count() int {
	if s == nil {
		return 0
	}
	return len(s.data)
}

// AnyMatch 是否存在匹配的元素
func (s *Stream[T]) AnyMatch(predicate func(T) bool) bool {
	if s == nil || predicate == nil {
		return false
	}
	for _, item := range s.data {
		if predicate(item) {
			return true
		}
	}
	return false
}

// AllMatch 是否所有元素都匹配
func (s *Stream[T]) AllMatch(predicate func(T) bool) bool {
	if s == nil || predicate == nil {
		return false
	}
	for _, item := range s.data {
		if !predicate(item) {
			return false
		}
	}
	return true
}

// Distinct 去重
func (s *Stream[T]) Distinct() *Stream[T] {
	if s == nil {
		return &Stream[T]{data: make([]T, 0)}
	}
	seen := make(map[any]bool)
	var result []T
	for _, item := range s.data {
		if !seen[any(item)] {
			seen[any(item)] = true
			result = append(result, item)
		}
	}
	return &Stream[T]{data: result}
}

// Limit 限制数量
func (s *Stream[T]) Limit(n int) *Stream[T] {
	if s == nil {
		return &Stream[T]{data: make([]T, 0)}
	}
	if n < 0 {
		n = 0
	}
	if n > len(s.data) {
		n = len(s.data)
	}
	return &Stream[T]{data: s.data[:n]}
}

// Skip 跳过元素
func (s *Stream[T]) Skip(n int) *Stream[T] {
	if s == nil {
		return &Stream[T]{data: make([]T, 0)}
	}
	if n < 0 {
		n = 0
	}
	if n >= len(s.data) {
		return &Stream[T]{data: make([]T, 0)}
	}
	return &Stream[T]{data: s.data[n:]}
}