// 用于slice 去重 及 检查元素是否存在于 slice 中
// 去重,支持 booleans, numbers, strings, pointers, channels, arrays of comparable types
//
//	t := Unique(s []T)
//
// 元素检查,支持 booleans, numbers, strings, pointers, channels, arrays of comparable types
//
//	in:= IsExists(s []T)
//	ok := in(a)
package tools

import "fmt"

// 取两个切片的差集
func Difference[T comparable](a, b []T) ([]T, []T) {
	var at, bt []T
	ain := IsExists(a)
	for _, i := range b {
		if !ain(i) {
			bt = append(bt, i)
		}
	}
	bin := IsExists(b)
	for _, i := range a {
		if !bin(i) {
			at = append(at, i)
		}
	}
	return at, bt
}

// 取两个切片的交集
func Intersection[T comparable](a, b []T) []T {
	var tmp []T
	bin := IsExists(b)
	for _, i := range a {
		if bin(i) {
			tmp = append(tmp, i)
		}
	}
	ain := IsExists(b)
	for _, i := range b {
		if ain(i) {
			tmp = append(tmp, i)
		}
	}
	return Unique(tmp)
}

// 取两个切片的并集
func Union[T comparable](a, b []T) []T {
	a = append(a, b...)
	return Unique(a)
}

func Unique[T comparable](s []T) []T {
	if len(s) == 0 {
		return []T{}
	}
	m := sliceToMap(s)
	v := make([]T, 0, len(m))
	for k := range m {
		v = append(v, k)
	}
	return v
}

func IsExists[T comparable](s []T) func(v T) bool {
	m := sliceToMap(s)
	return func(v T) bool {
		_, ok := m[v]
		return ok
	}
}

func sliceToMap[T comparable](s []T) map[T]struct{} {
	m := make(map[T]struct{}, len(s))
	for _, i := range s {
		if _, ok := m[i]; !ok {
			m[i] = struct{}{}
		}
	}
	return m
}

// []any{} 转 []string{}
func AtosSlice(a []any) []string {
	s := make([]string, 0, len(a))
	for _, i := range a {
		s = append(s, fmt.Sprintf("%v", i))
	}
	return s

}