package builtin

import (
	"sort"

	"gitee.com/blizzard1413/dsl/function"
	"gitee.com/blizzard1413/dsl/types"
)

// RegisterArray 注册所有数组函数
func RegisterArray(registry function.Registry) error {
	arrayFuncs := []struct {
		name string
		fn   func([]interface{}) (interface{}, error)
		sig  *function.Signature
	}{
		{"Array.length", arrayLength, function.NewSignature([]types.Type{types.NewArrayType(types.NewAnyType())}, types.NewNumberType())},
		{"Array.sort", arraySort, function.NewSignature([]types.Type{types.NewArrayType(types.NewAnyType())}, types.NewArrayType(types.NewAnyType()))},
		// map, filter, reduce, find 需要在求值器中实现，因为它们需要 Lambda 表达式
	}

	for _, af := range arrayFuncs {
		if err := registry.RegisterNative(af.name, af.sig, af.fn); err != nil {
			return err
		}
	}

	return nil
}

// arrayLength 返回数组长度
func arrayLength(args []interface{}) (interface{}, error) {
	arr := toArray(args[0])
	return float64(len(arr)), nil
}

// ArrayMap 对数组每个元素应用函数（需要在求值器中调用）
func ArrayMap(arr []interface{}, fn func(interface{}) interface{}) []interface{} {
	result := make([]interface{}, len(arr))
	for i, elem := range arr {
		result[i] = fn(elem)
	}
	return result
}

// ArrayFilter 过滤数组元素（需要在求值器中调用）
func ArrayFilter(arr []interface{}, predicate func(interface{}) bool) []interface{} {
	result := make([]interface{}, 0)
	for _, elem := range arr {
		if predicate(elem) {
			result = append(result, elem)
		}
	}
	return result
}

// ArrayReduce 归约数组（需要在求值器中调用）
func ArrayReduce(arr []interface{}, initial interface{}, reducer func(interface{}, interface{}) interface{}) interface{} {
	accumulator := initial
	for _, elem := range arr {
		accumulator = reducer(accumulator, elem)
	}
	return accumulator
}

// arraySort 排序数组（数字排序）
func arraySort(args []interface{}) (interface{}, error) {
	arr := toArray(args[0])

	// 复制数组
	result := make([]interface{}, len(arr))
	copy(result, arr)

	// 尝试作为数字排序
	sort.Slice(result, func(i, j int) bool {
		a := toFloat64(result[i])
		b := toFloat64(result[j])
		return a < b
	})

	return result, nil
}

// ArrayFind 查找第一个满足条件的元素（需要在求值器中调用）
func ArrayFind(arr []interface{}, predicate func(interface{}) bool) interface{} {
	for _, elem := range arr {
		if predicate(elem) {
			return elem
		}
	}
	return nil
}