package cache

import (
	"reflect"
	"slices"
	"sort"
)

// 分页相关类型定义
type (
	// PagingFilterFunc 过滤回调函数类型
	// 过滤函数用于决定数据项是否应该包含在查询结果中：
	// - 返回值为 true：表示该数据项满足过滤条件，应包含在结果中
	// - 返回值为 false：表示该数据项不满足过滤条件，应排除在结果之外
	// 例如，过滤价格大于100的商品：
	//   func(item Product) bool {
	//     return item.Price > 100
	//   }
	// 过滤特定类型的装备：
	//   func(item Equipment) bool {
	//     return item.Type == "武器" || item.Type == "盔甲"
	//   }
	PagingFilterFunc[T any] func(item T) bool

	// PagingCompareFunc 比较回调函数类型，用于排序
	// 比较函数的返回值定义了两个元素在排序中的相对位置：
	// - 返回值 < 0：表示a应该排在b之前
	// - 返回值 == 0：表示a和b在排序中地位相等
	// - 返回值 > 0：表示a应该排在b之后
	// 例如，实现升序排序：
	//   func(a, b int) int {
	//     return a - b
	//   }
	// 实现降序排序：
	//   func(a, b int) int {
	//     return b - a
	//   }
	PagingCompareFunc[T any] func(a, b T) int

	// Paging 泛型分页数据结构
	Paging[T any] struct {
		data []T
	}
)

// NewPaging 创建新的Paging实例
func NewPaging[T any]() *Paging[T] {
	return &Paging[T]{
		data: make([]T, 0),
	}
}

// Add 添加数据到Paging
func (p *Paging[T]) Add(item T) {
	p.data = append(p.data, item)
}

// AddAll 批量添加数据到Paging
func (p *Paging[T]) AddAll(items []T) {
	p.data = append(p.data, items...)
}

// 根据指定的 comparator fn排序
func (p *Paging[T]) Sort(comparator PagingCompareFunc[T]) {
	if comparator == nil || p.Count() <= 1 {
		return
	}

	sorted := make([]T, 0, len(p.data))
	copy(sorted, p.data)

	sort.SliceStable(sorted, func(i, j int) bool {
		return comparator(sorted[i], sorted[j]) < 0
	})

	p.data = sorted
}

// Query 查询方法，支持分页、过滤和排序
// filter参数为本次查询的过滤条件，comparator参数为本次查询的比较条件
func (p *Paging[T]) Query(pageNum, pageSize int32, filter PagingFilterFunc[T], comparator PagingCompareFunc[T]) (total int32, data []T) {
	// 验证参数
	if pageNum < 1 {
		pageNum = 1
	}
	if pageSize < 1 {
		pageSize = 10
	}

	// 应用过滤
	filteredData := make([]T, 0, len(p.data))
	for _, item := range p.data {
		if filter == nil || filter(item) {
			filteredData = append(filteredData, item)
		}
	}

	// 计算总数
	total = int32(len(filteredData))
	if total == 0 {
		return 0, nil
	}

	// 应用排序
	if comparator != nil {
		sort.SliceStable(filteredData, func(i, j int) bool {
			return comparator(filteredData[i], filteredData[j]) < 0
		})
	}

	// 计算分页
	start := (pageNum - 1) * pageSize
	if start >= total {
		return total, nil
	}

	end := min(start+pageSize, total)

	return total, filteredData[start:end]
}

// Clear 清空所有数据
func (p *Paging[T]) Clear() {
	p.data = make([]T, 0)
}

// Count 获取总数据量
func (p *Paging[T]) Count() int32 {
	return int32(len(p.data))
}

// IndexOf 返回元素 item 在内部切片中的下标，找不到返回 -1。
// 使用 reflect.DeepEqual 进行比较，适用于大多数类型。
func (p *Paging[T]) IndexOf(item T) int {
	for i, v := range p.data {
		if reflect.DeepEqual(v, item) {
			return i
		}
	}
	return -1
}

// Remove 删除第一次出现的指定元素，删除成功返回 被删除的元素 和 true，否则返回零值和 false。
func (p *Paging[T]) Remove(item T) (T, bool) {
	idx := p.IndexOf(item)
	var zero T
	if idx == -1 {
		return zero, false
	}
	return p.RemoveAt(idx)
}

// RemoveAt 删除指定下标的元素（按切片索引），成功返回 被删除的元素 和 true，索引越界返回 零值 和 false。
func (p *Paging[T]) RemoveAt(index int) (T, bool) {
	var zero T
	if index < 0 || index >= len(p.data) {
		return zero, false
	}
	removed := p.data[index]
	p.data = slices.Delete(p.data, index, index+1)
	return removed, true
}

// ForEach 遍历所有元素
func (p *Paging[T]) ForEach(f func(item T)) {
	for _, item := range p.data {
		f(item)
	}
}