package utils

import (
	"sort"
	"sync"
	"sync/atomic"
)

// SlicePool 泛型切片池
type SlicePool[T any] struct {
	pool     sync.Pool
	reused   int64
	maxCap   int // 最大保留容量
	initCap  int // 初始化容量
}

// NewSlicePool 创建新的切片池
func NewSlicePool[T any](initCap, maxCap int) *SlicePool[T] {
	if initCap <= 0 {
		initCap = 16
	}
	if maxCap <= 0 {
		maxCap = 1024
	}
	
	return &SlicePool[T]{
		pool: sync.Pool{
			New: func() interface{} {
				slice := make([]T, 0, initCap)
				return &slice
			},
		},
		initCap: initCap,
		maxCap:  maxCap,
	}
}

// Get 获取切片
func (p *SlicePool[T]) Get() []T {
	slicePtr := p.pool.Get().(*[]T)
	slice := *slicePtr
	slice = slice[:0] // 重置长度但保留容量
	atomic.AddInt64(&p.reused, 1)
	return slice
}

// Put 归还切片
func (p *SlicePool[T]) Put(slice []T) {
	if slice == nil {
		return
	}
	
	// 如果容量超过最大限制，不放回池中
	if cap(slice) > p.maxCap {
		return
	}
	
	// 清空切片内容，避免内存泄露
	for i := range slice {
		var zero T
		slice[i] = zero
	}
	slice = slice[:0]
	
	p.pool.Put(&slice)
}

// GetWithCapacity 获取指定容量的切片
func (p *SlicePool[T]) GetWithCapacity(capacity int) []T {
	slice := p.Get()
	if cap(slice) < capacity {
		// 如果容量不足，创建新的切片
		p.Put(slice) // 归还原来的
		return make([]T, 0, capacity)
	}
	return slice
}

// GetReusedCount 获取复用次数
func (p *SlicePool[T]) GetReusedCount() int64 {
	return atomic.LoadInt64(&p.reused)
}

// 预定义的常用类型切片池
var (
	StringSlicePool = NewSlicePool[string](32, 1024)
	IntSlicePool    = NewSlicePool[int](32, 1024)
	ByteSlicePool   = NewSlicePool[byte](256, 64*1024)
)

// DeduplicateStrings 高效字符串去重 - 简化版本
func DeduplicateStrings(slice []string) []string {
	if len(slice) <= 1 {
		return slice
	}
	
	// 使用最简单高效的实现
	seen := make(map[string]struct{}, len(slice))
	result := make([]string, 0, len(slice))
	
	for _, item := range slice {
		if _, exists := seen[item]; !exists {
			seen[item] = struct{}{}
			result = append(result, item)
		}
	}
	
	return result
}

// DeduplicateInts 高效整数去重
func DeduplicateInts(slice []int) []int {
	if len(slice) <= 1 {
		return slice
	}
	
	result := IntSlicePool.Get()
	defer IntSlicePool.Put(result)
	
	seen := make(map[int]struct{}, len(slice))
	
	for _, item := range slice {
		if _, exists := seen[item]; !exists {
			seen[item] = struct{}{}
			result = append(result, item)
		}
	}
	
	final := make([]int, len(result))
	copy(final, result)
	return final
}

// SortAndDeduplicateStrings 排序并去重字符串
func SortAndDeduplicateStrings(slice []string) []string {
	if len(slice) <= 1 {
		return slice
	}
	
	// 先排序
	sort.Strings(slice)
	
	// 再去重（对已排序的切片更高效）
	result := StringSlicePool.Get()
	defer StringSlicePool.Put(result)
	
	result = append(result, slice[0])
	for i := 1; i < len(slice); i++ {
		if slice[i] != slice[i-1] {
			result = append(result, slice[i])
		}
	}
	
	final := make([]string, len(result))
	copy(final, result)
	return final
}

// SortAndDeduplicateInts 排序并去重整数
func SortAndDeduplicateInts(slice []int) []int {
	if len(slice) <= 1 {
		return slice
	}
	
	sort.Ints(slice)
	
	result := IntSlicePool.Get()
	defer IntSlicePool.Put(result)
	
	result = append(result, slice[0])
	for i := 1; i < len(slice); i++ {
		if slice[i] != slice[i-1] {
			result = append(result, slice[i])
		}
	}
	
	final := make([]int, len(result))
	copy(final, result)
	return final
}