package GoUtil

import (
	"fmt"
	"sort"
	"strconv"
	"strings"
)

func IntToInt32(d []int) []int32 {
	r := make([]int32, 0, len(d))
	for _, d := range d {
		r = append(r, int32(d))
	}
	return r
}

func Int32ToInt(d []int32) []int {
	r := make([]int, 0, len(d))
	for _, d := range d {
		r = append(r, int(d))
	}
	return r
}

func StringToInt(d []string) []int {
	r := make([]int, 0, len(d))
	for _, d := range d {
		n, _ := strconv.Atoi(d)
		r = append(r, n)
	}
	return r
}

func RandPopSlice(slice []int) ([]int, int) {
	slen := len(slice)
	if slen == 0 {
		return slice, -1
	}
	Id := GetRand().Intn(slen)
	Val := slice[Id]
	Slice2 := append(slice[0:Id], slice[Id+1:]...)
	return Slice2, Val
}

func RandSlice(slice []int) int {
	slen := len(slice)
	if slen == 0 {
		return 0
	}
	Id := GetRand().Intn(slen)
	return slice[Id]
}

func RandSliceNum(s []int, num int) []int {
	slice := make([]int, len(s))
	copy(slice, s)
	r := make([]int, 0, num)
	if num <= 0 || len(slice) < num {
		return slice
	}

	for i := 0; i < num; i++ {
		Id := GetRand().Intn(len(slice))
		r = append(r, slice[Id])
		slice = append(slice[0:Id], slice[Id+1:]...)
	}
	return r
}

func RandSliceNum2(s []interface{}, num int) []interface{} {
	slice := make([]interface{}, len(s))
	copy(slice, s)
	r := make([]interface{}, 0, num)
	if num <= 0 || len(slice) < num {
		return slice
	}

	for i := 0; i < num; i++ {
		Id := GetRand().Intn(len(slice))
		r = append(r, slice[Id])
		slice = append(slice[0:Id], slice[Id+1:]...)
	}
	return r
}

func RandSliceNumNonAdjacent(s []int, num int) []int {
	slice := make([]int, len(s))
	copy(slice, s)
	if len(slice) < 2*num {
		return nil
	}
	sort.Ints(slice)
	result := make([]int, 0, num)
	for len(result) < num {
		Id := GetRand().Intn(len(slice))
		result = append(result, slice[Id])
		slice = SubAdjacentElemSlice(slice, Id)
	}
	return result
}

func SubAdjacentElemSlice(s []int, Id int) []int {
	r := make([]int, 0, len(s))
	for k, v := range s {
		if k < Id-1 || k > Id+1 {
			r = append(r, v)
		}
	}
	return r
}

func RandStringSlice(slice []string) string {
	slen := len(slice)
	if slen == 0 {
		return ""
	}
	Id := GetRand().Intn(slen)
	return slice[Id]
}

func SliceStringToInt(s []string) []int {
	if len(s) == 0 {
		return []int{}
	}
	r := make([]int, 0, len(s))
	for _, v := range s {
		v = strings.Trim(v, " ")
		v1, _ := strconv.Atoi(v)
		r = append(r, v1)
	}
	return r
}

func SliceIntToInt32(s []int) []int32 {
	r := make([]int32, 0, len(s))
	for _, v := range s {
		r = append(r, int32(v))
	}
	return r
}

func PopElemSlice(s []int, Id int) ([]int, bool) {
	for k, v := range s {
		if v == Id {
			return append(s[0:k], s[k+1:]...), true
		}
	}
	return s, false
}

func ElemInSlice(s []int, Id int) bool {
	for _, v := range s {
		if v == Id {
			return true
		}
	}
	return false
}

func GetElemNum(s []int, Id int) int {
	n := 0
	for _, v := range s {
		if v == Id {
			n++
		}
	}
	return n
}

func InArray(Id int, s []int) bool {
	for _, v := range s {
		if v == Id {
			return true
		}
	}
	return false
}

func InStringArray(Id string, s []string) bool {
	for _, v := range s {
		if v == Id {
			return true
		}
	}
	return false
}

// toInterfaceSlice converts a slice of strings to a slice of empty interfaces
func ToInterfaceSlice(slice []string) []interface{} {
	result := make([]interface{}, len(slice))
	for i, v := range slice {
		result[i] = v
	}
	return result
}

// a - b
func SubSlices(a, b []int) []int {
	result := make([]int, 0, len(a))
	for _, num := range a {
		if !InArray(num, b) {
			result = append(result, num)
		}
	}
	return result
}

func PopSlice(s []int) (int, []int) {
	if len(s) == 0 {
		return -1, s
	}
	return s[0], s[1:]
}

func SliceEqual(a, b []int) bool {
	if len(a) != len(b) {
		return false
	}
	sort.Ints(a)
	sort.Ints(b)
	for k, v := range a {
		if v != b[k] {
			return false
		}
	}
	return true
}

func InitNumSlice(start, end int) []int {
	result := make([]int, 0, end-start+1)
	for i := start; i <= end; i++ {
		result = append(result, i)
	}
	return result
}

func IntSliceToString(slice []int) string {
	str := fmt.Sprintf("%v", slice)
	str = strings.Trim(str, "[]")
	return str
}

func PopStringArray(s []string) (string, []string) {
	if len(s) == 0 {
		return "", s
	}
	return s[0], s[1:]
}

func ShuffleStringArray(s []string) []string {
	r := make([]string, len(s))
	perm := GetRand().Perm(len(s))
	for i, v := range perm {
		r[v] = s[i]
	}
	return r
}

func ShuffleArray(s []int) []int {
	r := make([]int, len(s))
	perm := GetRand().Perm(len(s))
	for i, v := range perm {
		r[v] = s[i]
	}
	return r
}

func IsContain(s []int, s2 []int) bool {
	for _, v := range s2 {
		if !InArray(v, s) {
			return false
		}
		s = SubSlices(s, []int{v})
	}
	return true
}

func IsSameElem(s []int) bool {
	r := make(map[int]struct{})
	for _, v := range s {
		if _, ok := r[v]; ok {
			return true
		}
		r[v] = struct{}{}
	}
	return false
}