nativeFns

var ArrayFns = map[string]NativeFunction{
	"includes": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 2 || args[0].GetType() != interpreter_env.Array {
			return interpreter_makers.MkBoolean(false)
		}

		return interpreter_makers.MkBoolean(slices.Contains(args[0].(interpreter_env.ArrayVal).GetElements(), args[1].GetValue()))
	},
	"push": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 2 || args[0].GetType() != interpreter_env.Array {
			return interpreter_makers.MkNull()
		}

		arr := args[0].GetValue().([]interpreter_env.RuntimeValue)

		arr = append(arr, args[1:]...)

		return interpreter_makers.MkArray(arr)
	},
	"pop": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 || args[0].GetType() != interpreter_env.Array {
			return interpreter_makers.MkNull()
		}
		arr := args[0].GetValue().([]interpreter_env.RuntimeValue)
		arr = arr[:len(arr)-1]

		return interpreter_makers.MkArray(arr)
	},
	"shift": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 || args[0].GetType() != interpreter_env.Array {
			return interpreter_makers.MkNull()
		}
		arr := args[0].GetValue().([]interpreter_env.RuntimeValue)
		arr = arr[len(arr)-1:]

		return interpreter_makers.MkArray(arr)
	},
	"indexOf": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 2 || args[0].GetType() != interpreter_env.Array {
			return interpreter_makers.MkNull()
		}

		arr := args[0].(interpreter_env.ArrayVal).GetElements()
		searchElement := args[1].GetValue()

		for index, element := range arr {
			if element == searchElement {
				return interpreter_makers.MkNumber(float64(index))
			}
		}

		return interpreter_makers.MkNumber(-1)
	},
}

var BooleanFns = map[string]NativeFunction{
	"isNaN": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 {
			return interpreter_makers.MkBoolean(true)
		}

		return interpreter_makers.MkBoolean(args[0].GetValue() == "NaN" && args[0].GetType() == interpreter_env.Number)
	},
	"isNull": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 {
			return interpreter_makers.MkBoolean(false)
		}

		return interpreter_makers.MkBoolean(args[0].GetValue() == nil)
	},
}

var ConsoleFns = map[string]NativeFunction{
	"print": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {

		for _, arg := range args {
			printPrimitive(arg)
			fmt.Println("")
		}

		return interpreter_makers.MkNull()
	},
	"prompt": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 {
			return interpreter_makers.MkString("")
		}

		fmt.Print(args[0].GetValue())
		var input string
		_, err := fmt.Scanln(&input)
		if err != nil {
			return nil
		}
		return interpreter_makers.MkString(input)
	},
}

var NativeFunctions = utils.MergeMaps(BooleanFns, ConsoleFns, NumberFns, ParseFns, StringFns, VarietyFns, ArrayFns)

var NumberFns = map[string]NativeFunction{
	"randNum": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) <= 1 {
			return interpreter_makers.MkNan()
		}

		min := int(args[0].GetValue().(float64))
		max := int(args[1].GetValue().(float64))

		if min > max {
			return interpreter_makers.MkNan()
		}
		source := rand.NewSource(time.Now().UnixNano())
		r := rand.New(source)
		num := r.Intn(max-min+1) + min
		return interpreter_makers.MkNumber(float64(num))
	},
	"pow": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) <= 1 {
			return interpreter_makers.MkNan()
		}

		base := args[0].GetValue().(float64)
		exponent := args[1].GetValue().(float64)
		result := math.Pow(base, exponent)
		return interpreter_makers.MkNumber(result)
	},
}

var ParseFns = map[string]NativeFunction{
	"string": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 {
			return interpreter_makers.MkString("")
		}

		switch args[0].GetType() {
		case interpreter_env.Null:
			return interpreter_makers.MkString("null")
		case interpreter_env.Object:
			return interpreter_makers.MkString("object")
		case interpreter_env.Array:
			arr := args[0].GetValue().([]interpreter_env.RuntimeValue)
			s := "["
			for i, v := range arr {
				s += fmt.Sprintf("%v", v.GetValue())
				if i != len(arr)-1 {
					s += ", "
				}
			}
			s += "]"
			return interpreter_makers.MkString(s)
		default:
			s := fmt.Sprintf("%v", args[0].GetValue())
			return interpreter_makers.MkString(s)
		}
	},
	"num": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 {
			return interpreter_makers.MkNan()
		}

		i, err := strconv.ParseFloat(args[0].GetValue().(string), 64)

		if err != nil {
			return interpreter_makers.MkNan()
		}

		return interpreter_makers.MkNumber(i)
	},
	"bool": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 {
			return interpreter_makers.MkBoolean(false)
		}

		result := EvaluateTruthyFalsyValues(args[0])

		return interpreter_makers.MkBoolean(result)
	},
}

var StringFns = map[string]NativeFunction{
	"toUpperCase": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 || args[0].GetType() != interpreter_env.String {
			return interpreter_makers.MkString("")
		}

		str := args[0].GetValue().(string)
		result := strings.ToUpper(str)
		return interpreter_makers.MkString(result)
	},
	"toLowerCase": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 || args[0].GetType() != interpreter_env.String {
			return interpreter_makers.MkString("")
		}

		str := args[0].GetValue().(string)
		result := strings.ToLower(str)
		return interpreter_makers.MkString(result)
	},
	"capitalize": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 || args[0].GetType() != interpreter_env.String {
			return interpreter_makers.MkString("")
		}

		str := args[0].GetValue().(string)
		if len(str) <= 0 {
			return interpreter_makers.MkString("")
		}
		result := strings.ToUpper(str[:1]) + str[1:]
		return interpreter_makers.MkString(result)
	},
	"startsWith": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 2 || args[0].GetType() != interpreter_env.String || args[1].GetType() != interpreter_env.String {
			return interpreter_makers.MkBoolean(false)
		}

		str := args[0].GetValue().(string)
		prefix := args[1].GetValue().(string)
		result := strings.HasPrefix(str, prefix)
		return interpreter_makers.MkBoolean(result)
	},
	"endsWith": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 2 || args[0].GetType() != interpreter_env.String || args[1].GetType() != interpreter_env.String {
			return interpreter_makers.MkBoolean(false)
		}

		str := args[0].GetValue().(string)
		suffix := args[1].GetValue().(string)
		result := strings.HasSuffix(str, suffix)
		return interpreter_makers.MkBoolean(result)
	},
	"reverseString": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 || args[0].GetType() != interpreter_env.String {
			return interpreter_makers.MkString("")
		}

		str := args[0].GetValue().(string)
		runes := []rune(str)
		for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
			runes[i], runes[j] = runes[j], runes[i]
		}
		result := string(runes)
		return interpreter_makers.MkString(result)
	},
	"concat": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 {
			return interpreter_makers.MkString("")
		}
		result := ""
		for _, arg := range args {
			if arg.GetType() != interpreter_env.String {
				return interpreter_makers.MkString("")
			}
			result += arg.GetValue().(string)
		}
		return interpreter_makers.MkString(result)
	},
}

var VarietyFns = map[string]NativeFunction{
	"len": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 {
			return interpreter_makers.MkNan()
		}

		switch args[0].GetType() {
		case interpreter_env.String:
			arg, ok := args[0].GetValue().(string)
			if !ok {
				return interpreter_makers.MkNan()
			}
			return interpreter_makers.MkNumber(float64(len(arg)))
		case interpreter_env.Array:
			arg, ok := args[0].GetValue().([]interpreter_env.RuntimeValue)
			if !ok {
				return interpreter_makers.MkNan()
			}
			return interpreter_makers.MkNumber(float64(len(arg)))
		default:
			return interpreter_makers.MkNan()
		}

	},
	"typeof": func(args []interpreter_env.RuntimeValue, env interpreter_env.Environment) interpreter_env.RuntimeValue {
		if len(args) < 1 {
			return interpreter_makers.MkNull()
		}

		return interpreter_makers.MkString(string(args[0].GetType()))
	},
}