import kotlin.reflect.KFunction
import kotlin.reflect.KParameter
import kotlin.reflect.full.extensionReceiverParameter
import kotlin.reflect.full.instanceParameter


object FunctionBinding {
    fun convertBinding(
        kFunction: KFunction<*>,
        receiver: Any,
        arguments: Map<DataParameter, Any?>,
        hasLambda: Boolean,
        configureLambdaHandler: ConfigureLambdaHandler

		options = append(options, cel.Function("test",
			cel.Overload("test", []*cel.Type{}, cel.BoolType,
				cel.FunctionBinding(func(args ...ref.Val) ref.Val {
					return types.True
				}))))
	}

	if t.version >= 1 {
		options = append(options, cel.Function("test",
			cel.Overload("test", []*cel.Type{}, cel.BoolType,
				cel.FunctionBinding(func(args ...ref.Val) ref.Val {

    override fun callBy(receiver: Any, binding: Map<DataParameter, Any?>, hasLambda: Boolean): DeclarativeRuntimeFunction.InvocationResult {
        val params = FunctionBinding.convertBinding(kFunction, receiver, binding, hasLambda, configureLambdaHandler)
            ?: error("signature of $kFunction does not match the arguments: $binding")
        val captor = params.valueCaptor

            // TODO: `convertBinding` is invoked here with the receiverClass passed as the receiver and non-resolved argument origins; this probably needs a different API shape
            if (function.name == name && FunctionBinding.convertBinding(function, receiverClass, parameterValueBinding.bindingMap, parameterValueBinding.providesConfigureBlock, configureLambdaHandler) != null) {

				return findAll(str, regex, types.Int(-1))
			})),
		cel.MemberOverload("string_find_all_string_int",
			[]*cel.Type{cel.StringType, cel.StringType, cel.IntType},
			cel.ListType(cel.StringType),
			cel.FunctionBinding(findAll)),
	},
}

func (*regex) CompileOptions() []cel.EnvOption {
	options := []cel.EnvOption{}
	for name, overloads := range regexLibraryDecls {
		options = append(options, cel.Function(name, overloads...))

	return "format"
}

func ZeroArgumentFunctionBinding(binding func() ref.Val) decls.OverloadOpt {
	return func(o *decls.OverloadDecl) (*decls.OverloadDecl, error) {
		wrapped, err := decls.FunctionBinding(func(values ...ref.Val) ref.Val { return binding() })(o)
		if err != nil {
			return nil, err
		}
		if len(wrapped.ArgTypes()) != 0 {
			return nil, fmt.Errorf("function binding must have 0 arguments")
		}

			cel.BinaryBinding(authorizerGroup))},
	"serviceAccount": {
		cel.MemberOverload("authorizer_serviceaccount", []*cel.Type{AuthorizerType, cel.StringType, cel.StringType}, AuthorizerType,
			cel.FunctionBinding(authorizerServiceAccount))},
	"resource": {
		cel.MemberOverload("groupcheck_resource", []*cel.Type{GroupCheckType, cel.StringType}, ResourceCheckType,
			cel.BinaryBinding(groupCheckResource))},
	"subresource": {