package go_lib

import (
	"reflect"
	"sort"
)

func ArrayKeys(arr interface{}) []interface{} {
	v := reflect.ValueOf(arr)
	if v.Kind() != reflect.Map {
		return nil
	}
	
	keys := make([]interface{}, 0, v.Len())
	for _, key := range v.MapKeys() {
		keys = append(keys, key.Interface())
	}
	return keys
}

func ArrayValues(arr interface{}) []interface{} {
	v := reflect.ValueOf(arr)
	if v.Kind() != reflect.Map {
		return nil
	}
	
	values := make([]interface{}, 0, v.Len())
	for _, key := range v.MapKeys() {
		values = append(values, v.MapIndex(key).Interface())
	}
	return values
}

func InArray(needle interface{}, haystack []interface{}) bool {
	for _, item := range haystack {
		if reflect.DeepEqual(needle, item) {
			return true
		}
	}
	return false
}

func InArrayString(needle string, haystack []string) bool {
	for _, item := range haystack {
		if needle == item {
			return true
		}
	}
	return false
}

func InArrayInt(needle int, haystack []int) bool {
	for _, item := range haystack {
		if needle == item {
			return true
		}
	}
	return false
}

func ArraySearch(needle interface{}, haystack []interface{}) int {
	for i, item := range haystack {
		if reflect.DeepEqual(needle, item) {
			return i
		}
	}
	return -1
}

func ArrayReverse(arr []interface{}) []interface{} {
	result := make([]interface{}, len(arr))
	for i, item := range arr {
		result[len(arr)-1-i] = item
	}
	return result
}

func ArrayReverseString(arr []string) []string {
	result := make([]string, len(arr))
	for i, item := range arr {
		result[len(arr)-1-i] = item
	}
	return result
}

func ArrayReverseInt(arr []int) []int {
	result := make([]int, len(arr))
	for i, item := range arr {
		result[len(arr)-1-i] = item
	}
	return result
}

func ArrayUnique(arr []interface{}) []interface{} {
	keys := make(map[interface{}]bool)
	result := make([]interface{}, 0)
	
	for _, item := range arr {
		if !keys[item] {
			keys[item] = true
			result = append(result, item)
		}
	}
	return result
}

func ArrayUniqueString(arr []string) []string {
	keys := make(map[string]bool)
	result := make([]string, 0)
	
	for _, item := range arr {
		if !keys[item] {
			keys[item] = true
			result = append(result, item)
		}
	}
	return result
}

func ArrayUniqueInt(arr []int) []int {
	keys := make(map[int]bool)
	result := make([]int, 0)
	
	for _, item := range arr {
		if !keys[item] {
			keys[item] = true
			result = append(result, item)
		}
	}
	return result
}

func ArrayMerge(arrays ...[]interface{}) []interface{} {
	var result []interface{}
	for _, arr := range arrays {
		result = append(result, arr...)
	}
	return result
}

func ArrayMergeString(arrays ...[]string) []string {
	var result []string
	for _, arr := range arrays {
		result = append(result, arr...)
	}
	return result
}

func ArrayMergeInt(arrays ...[]int) []int {
	var result []int
	for _, arr := range arrays {
		result = append(result, arr...)
	}
	return result
}

func ArraySlice(arr []interface{}, offset int, length ...int) []interface{} {
	l := len(arr)
	if offset < 0 {
		offset = l + offset
	}
	
	if offset < 0 || offset >= l {
		return []interface{}{}
	}
	
	end := l
	if len(length) > 0 && length[0] > 0 {
		end = offset + length[0]
		if end > l {
			end = l
		}
	}
	
	return arr[offset:end]
}

func ArraySliceString(arr []string, offset int, length ...int) []string {
	l := len(arr)
	if offset < 0 {
		offset = l + offset
	}
	
	if offset < 0 || offset >= l {
		return []string{}
	}
	
	end := l
	if len(length) > 0 && length[0] > 0 {
		end = offset + length[0]
		if end > l {
			end = l
		}
	}
	
	return arr[offset:end]
}

func ArraySliceInt(arr []int, offset int, length ...int) []int {
	l := len(arr)
	if offset < 0 {
		offset = l + offset
	}
	
	if offset < 0 || offset >= l {
		return []int{}
	}
	
	end := l
	if len(length) > 0 && length[0] > 0 {
		end = offset + length[0]
		if end > l {
			end = l
		}
	}
	
	return arr[offset:end]
}

func ArrayChunk(arr []interface{}, size int) [][]interface{} {
	if size <= 0 {
		return nil
	}
	
	var chunks [][]interface{}
	for i := 0; i < len(arr); i += size {
		end := i + size
		if end > len(arr) {
			end = len(arr)
		}
		chunks = append(chunks, arr[i:end])
	}
	return chunks
}

func ArrayChunkString(arr []string, size int) [][]string {
	if size <= 0 {
		return nil
	}
	
	var chunks [][]string
	for i := 0; i < len(arr); i += size {
		end := i + size
		if end > len(arr) {
			end = len(arr)
		}
		chunks = append(chunks, arr[i:end])
	}
	return chunks
}

func ArrayChunkInt(arr []int, size int) [][]int {
	if size <= 0 {
		return nil
	}
	
	var chunks [][]int
	for i := 0; i < len(arr); i += size {
		end := i + size
		if end > len(arr) {
			end = len(arr)
		}
		chunks = append(chunks, arr[i:end])
	}
	return chunks
}

func ArraySum(arr []int) int {
	sum := 0
	for _, v := range arr {
		sum += v
	}
	return sum
}

func ArraySumFloat(arr []float64) float64 {
	sum := 0.0
	for _, v := range arr {
		sum += v
	}
	return sum
}

func ArrayProduct(arr []int) int {
	if len(arr) == 0 {
		return 0
	}
	product := 1
	for _, v := range arr {
		product *= v
	}
	return product
}

func ArrayProductFloat(arr []float64) float64 {
	if len(arr) == 0 {
		return 0
	}
	product := 1.0
	for _, v := range arr {
		product *= v
	}
	return product
}

func ArrayMin(arr []int) int {
	if len(arr) == 0 {
		return 0
	}
	min := arr[0]
	for _, v := range arr[1:] {
		if v < min {
			min = v
		}
	}
	return min
}

func ArrayMax(arr []int) int {
	if len(arr) == 0 {
		return 0
	}
	max := arr[0]
	for _, v := range arr[1:] {
		if v > max {
			max = v
		}
	}
	return max
}

func ArrayRand(arr []interface{}, num int) []interface{} {
	if num <= 0 || num > len(arr) {
		return nil
	}
	
	indices := make([]int, len(arr))
	for i := range indices {
		indices[i] = i
	}
	
	for i := len(indices) - 1; i > 0; i-- {
		j := randomInt(i + 1)
		indices[i], indices[j] = indices[j], indices[i]
	}
	
	result := make([]interface{}, num)
	for i := 0; i < num; i++ {
		result[i] = arr[indices[i]]
	}
	return result
}

func ArrayShuffle(arr []interface{}) []interface{} {
	result := make([]interface{}, len(arr))
	copy(result, arr)
	
	for i := len(result) - 1; i > 0; i-- {
		j := randomInt(i + 1)
		result[i], result[j] = result[j], result[i]
	}
	return result
}

func ArraySort(arr []int) []int {
	result := make([]int, len(arr))
	copy(result, arr)
	sort.Ints(result)
	return result
}

func ArraySortString(arr []string) []string {
	result := make([]string, len(arr))
	copy(result, arr)
	sort.Strings(result)
	return result
}

func ArrayRsort(arr []int) []int {
	result := make([]int, len(arr))
	copy(result, arr)
	sort.Sort(sort.Reverse(sort.IntSlice(result)))
	return result
}

func ArrayRsortString(arr []string) []string {
	result := make([]string, len(arr))
	copy(result, arr)
	sort.Sort(sort.Reverse(sort.StringSlice(result)))
	return result
}

func ArrayFilter(arr []interface{}, callback func(interface{}) bool) []interface{} {
	var result []interface{}
	for _, item := range arr {
		if callback(item) {
			result = append(result, item)
		}
	}
	return result
}

func ArrayMap(arr []interface{}, callback func(interface{}) interface{}) []interface{} {
	result := make([]interface{}, len(arr))
	for i, item := range arr {
		result[i] = callback(item)
	}
	return result
}