// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
// All rights reserved.

// func-builtins.go
package expr

import (
	"math"
	"strconv"
)

func isNilFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	result = args[0] == nil
	return
}

func isIntFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	result = IsInteger(args[0])
	return
}

func isFloatFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	result = IsFloat(args[0])
	return
}

func isBoolFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	result = IsBool(args[0])
	return
}

func isStringFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	result = IsString(args[0])
	return
}

func isFractionFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	result = IsFract(args[0])
	return
}

func isRationalFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	result = IsRational(args[0])
	return
}

func isListFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	result = IsList(args[0])
	return
}

func isDictionaryFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	result = IsDict(args[0])
	return
}

func intFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	switch v := args[0].(type) {
	case int64:
		result = v
	case float64:
		result = int64(math.Trunc(v))
	case bool:
		if v {
			result = int64(1)
		} else {
			result = int64(0)
		}
	case string:
		var i int
		if i, err = strconv.Atoi(v); err == nil {
			result = int64(i)
		}
	default:
		err = errCantConvert(name, v, "int")
	}
	return
}

func decFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	switch v := args[0].(type) {
	case int64:
		result = float64(v)
	case float64:
		result = v
	case bool:
		if v {
			result = float64(1)
		} else {
			result = float64(0)
		}
	case string:
		var f float64
		if f, err = strconv.ParseFloat(v, 64); err == nil {
			result = f
		}
	case *fraction:
		result = v.toFloat()
	default:
		err = errCantConvert(name, v, "float")
	}
	return
}

func fractFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	switch v := args[0].(type) {
	case int64:
		var den int64 = 1
		if len(args) > 1 {
			var ok bool
			if den, ok = args[1].(int64); !ok {
				err = errExpectedGot(name, "integer", args[1])
			} else if den == 0 {
				err = errDivisionByZero(name)
			}
		}
		if err == nil {
			result = newFraction(v, den)
		}
	case float64:
		result, err = float64ToFraction(v)
	case bool:
		if v {
			result = newFraction(1, 1)
		} else {
			result = newFraction(0, 1)
		}
	case string:
		result, err = makeGeneratingFraction(v)
	case *fraction:
		result = v
	default:
		err = errCantConvert(name, v, "float")
	}
	return
}

func iteratorFunc(ctx ExprContext, name string, args []any) (result any, err error) {
	return
}

func ImportBuiltinsFuncs(ctx ExprContext) {
	anyParams := []ExprFuncParam{
		newFuncParam(paramValue),
	}

	// ctx.RegisterFunc("isNil", &simpleFunctor{f: isNilFunc}, 1, 1)
	ctx.RegisterFunc2("isNil", newSimpleFunctor(isNilFunc), typeBoolean, anyParams)
	// ctx.RegisterFunc("isInt", &simpleFunctor{f: isIntFunc}, 1, 1)
	ctx.RegisterFunc2("isInt", newSimpleFunctor(isIntFunc), typeBoolean, anyParams)
	// ctx.RegisterFunc("isFloat", &simpleFunctor{f: isFloatFunc}, 1, 1)
	ctx.RegisterFunc2("isFloat", newSimpleFunctor(isFloatFunc), typeBoolean, anyParams)
	// ctx.RegisterFunc("isBool", &simpleFunctor{f: isBoolFunc}, 1, 1)
	ctx.RegisterFunc2("isBool", newSimpleFunctor(isBoolFunc), typeBoolean, anyParams)
	// ctx.RegisterFunc("isString", &simpleFunctor{f: isStringFunc}, 1, 1)
	ctx.RegisterFunc2("isString", newSimpleFunctor(isStringFunc), typeBoolean, anyParams)
	// ctx.RegisterFunc("isFraction", &simpleFunctor{f: isFractionFunc}, 1, 1)
	//ctx.RegisterFunc2("isFraction", &simpleFunctor{f: isFractionFunc}, typeBoolean, anyParams)
	// ctx.RegisterFunc("isFract", &simpleFunctor{f: isFractionFunc}, 1, 1)
	ctx.RegisterFunc2("isFract", newSimpleFunctor(isFractionFunc), typeBoolean, anyParams)
	// ctx.RegisterFunc("isRational", &simpleFunctor{f: isRationalFunc}, 1, 1)
	ctx.RegisterFunc2("isRational", newSimpleFunctor(isRationalFunc), typeBoolean, anyParams)
	// ctx.RegisterFunc("isList", &simpleFunctor{f: isListFunc}, 1, 1)
	ctx.RegisterFunc2("isList", newSimpleFunctor(isListFunc), typeBoolean, anyParams)
	// ctx.RegisterFunc("isDictionary", &simpleFunctor{f: isDictionaryFunc}, 1, 1)
	//ctx.RegisterFunc2("isDictionary", &simpleFunctor{f: isDictionaryFunc}, typeBoolean, anyParams)
	// ctx.RegisterFunc("isDict", &simpleFunctor{f: isDictionaryFunc}, 1, 1)
	ctx.RegisterFunc2("isDict", newSimpleFunctor(isDictionaryFunc), typeBoolean, anyParams)
	//ctx.RegisterFunc("int", &simpleFunctor{f: intFunc}, 1, 1)
	ctx.RegisterFunc2("int", newSimpleFunctor(intFunc), typeInt, anyParams)
	// ctx.RegisterFunc("dec", &simpleFunctor{f: decFunc}, 1, 1)
	ctx.RegisterFunc2("dec", newSimpleFunctor(decFunc), typeFloat, anyParams)
	// ctx.RegisterFunc("fract", &simpleFunctor{f: fractFunc}, 1, 2)
	ctx.RegisterFunc2("fract", newSimpleFunctor(fractFunc), typeFraction, []ExprFuncParam{
		newFuncParam(paramValue),
		newFuncParamFlagDef("denominator", pfOptional, 1),
	})
}

func init() {
	registerImport("base", ImportBuiltinsFuncs, "Base expression tools like isNil(), int(), etc.")
}