package example;

import io.micronaut.el.example.eligible.Eligible;
import io.micronaut.el.example.eligible.MinAmount;
import jakarta.inject.Singleton;

@Singleton
public class RegistrationService {

    @Eligible(value = "#{ fn:adult(customer.age) && fn:inEurope(customer.country) }", // (1)
              otherwise = "#{ customer.name += ' must be an adult in Europe' }", // (2)
              name = "REGISTER") // (3)
    public String register(Customer customer) {
        return "registered " + customer.name();
    }

    @Eligible("${ customer.country == Locale.GERMANY.country }") // (4)
    public String deposit(Customer customer,
                          @MinAmount(value = 100, inclusive = true,
                                     message = "Must be greater than ${inclusive == true ? 'or equal to ' : ''}{value}") // (5)
                          long amount) {
        return "deposited " + amount + " for " + customer.name();
    }
}

package example

import io.micronaut.el.example.eligible.Eligible
import io.micronaut.el.example.eligible.MinAmount
import jakarta.inject.Singleton

@Singleton
open class RegistrationService {

    @Eligible(value = "#{ fn:adult(customer.age) && fn:inEurope(customer.country) }", // (1)
              otherwise = "#{ customer.name += ' must be an adult in Europe' }", // (2)
              name = "REGISTER") // (3)
    open fun register(customer: Customer): String = "registered " + customer.name

    @Eligible("\${ customer.country == Locale.GERMANY.country }") // (4)
    open fun deposit(customer: Customer,
                     @MinAmount(value = 100, inclusive = true,
                                message = "Must be greater than \${inclusive == true ? 'or equal to ' : ''}{value}") // (5)
                     amount: Long): String = "deposited $amount for " + customer.name
}

package example

import io.micronaut.el.example.eligible.Eligible
import io.micronaut.el.example.eligible.MinAmount
import jakarta.inject.Singleton

@Singleton
class RegistrationService {

    @Eligible(value = '#{ fn:adult(customer.age) && fn:inEurope(customer.country) }', // (1)
              otherwise = "#{ customer.name += ' must be an adult in Europe' }", // (2)
              name = "REGISTER") // (3)
    String register(Customer customer) {
        "registered " + customer.name
    }

    @Eligible('${ customer.country == Locale.GERMANY.country }') // (4)
    String deposit(Customer customer,
                   @MinAmount(value = 100L, inclusive = true,
                              message = "Must be greater than \${inclusive == true ? 'or equal to ' : ''}{value}") // (5)
                   long amount) {
        "deposited " + amount + " for " + customer.name
    }
}

package example;

import io.micronaut.aop.InterceptorBean;
import io.micronaut.aop.MethodInterceptor;
import io.micronaut.aop.MethodInvocationContext;
import io.micronaut.el.CompiledELContext;
import io.micronaut.core.annotation.AnnotationValue;
import io.micronaut.core.type.Argument;
import io.micronaut.el.example.eligible.ConstraintMessages;
import io.micronaut.el.example.eligible.Eligible;
import io.micronaut.el.example.eligible.MinAmount;
import jakarta.el.ELManager;
import jakarta.el.ValueExpression;
import jakarta.inject.Singleton;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Singleton
@InterceptorBean(Eligible.class) // (1)
public class EligibleInterceptor implements MethodInterceptor<Object, Object> {

    private final Map<String, ValueExpression> expressions = new ConcurrentHashMap<>();

    @Override
    public Object intercept(MethodInvocationContext<Object, Object> context) {
        CompiledELContext elContext = new CompiledELContext();
        context.getParameterValueMap().forEach(elContext::setBean); // (2)

        for (Argument<?> argument : context.getArguments()) { // (5)
            AnnotationValue<MinAmount> constraint = argument.getAnnotationMetadata().getAnnotation(MinAmount.class);
            Object value = context.getParameterValueMap().get(argument.getName());
            if (constraint != null && value instanceof Number number && !satisfies(constraint, number.longValue())) {
                throw new NotEligibleException(ConstraintMessages.interpolate(constraint, value)); // (6)
            }
        }

        String condition = context.stringValue(Eligible.class).orElseThrow(); // (3)
        if (Boolean.TRUE.equals(expression(elContext, condition, Boolean.class).getValue(elContext))) {
            return context.proceed();
        }
        String message = context.stringValue(Eligible.class, "otherwise")
            .filter(otherwise -> !otherwise.isEmpty())
            .map(otherwise -> expression(elContext, otherwise, String.class).<String>getValue(elContext))
            .orElse(context.getMethodName() + " requires " + condition);
        throw new NotEligibleException(message);
    }

    private static boolean satisfies(AnnotationValue<MinAmount> constraint, long amount) {
        long minimum = constraint.longValue().orElseThrow();
        return constraint.booleanValue("inclusive").orElse(false) ? amount >= minimum : amount > minimum;
    }

    private ValueExpression expression(CompiledELContext elContext, String text, Class<?> expectedType) {
        return expressions.computeIfAbsent(text, key ->
            ELManager.getExpressionFactory().createValueExpression(elContext, key, expectedType)); // (4)
    }
}

package example

import io.micronaut.aop.InterceptorBean
import io.micronaut.aop.MethodInterceptor
import io.micronaut.aop.MethodInvocationContext
import io.micronaut.el.CompiledELContext
import io.micronaut.core.annotation.AnnotationValue
import io.micronaut.el.example.eligible.ConstraintMessages
import io.micronaut.el.example.eligible.Eligible
import io.micronaut.el.example.eligible.MinAmount
import jakarta.el.ELManager
import jakarta.el.ValueExpression
import jakarta.inject.Singleton
import java.util.concurrent.ConcurrentHashMap

@Singleton
@InterceptorBean(Eligible::class) // (1)
class EligibleInterceptor : MethodInterceptor<Any, Any> {

    private val expressions = ConcurrentHashMap<String, ValueExpression>()

    override fun intercept(context: MethodInvocationContext<Any, Any>): Any? {
        val elContext = CompiledELContext()
        context.parameterValueMap.forEach { (name, value) -> elContext.setBean(name, value) } // (2)

        for (argument in context.arguments) { // (5)
            val constraint = argument.annotationMetadata.getAnnotation(MinAmount::class.java)
            val value = context.parameterValueMap[argument.name]
            if (constraint != null && value is Number && !satisfies(constraint, value.toLong())) {
                throw NotEligibleException(ConstraintMessages.interpolate(constraint, value)) // (6)
            }
        }

        val condition = context.stringValue(Eligible::class.java).orElseThrow() // (3)
        if (expression(elContext, condition, Boolean::class.javaObjectType).getValue<Boolean?>(elContext) == true) {
            return context.proceed()
        }
        val otherwise = context.stringValue(Eligible::class.java, "otherwise").orElse("")
        val message = if (otherwise.isEmpty()) "${context.methodName} requires $condition"
            else expression(elContext, otherwise, String::class.java).getValue<String>(elContext)
        throw NotEligibleException(message)
    }

    private fun satisfies(constraint: AnnotationValue<MinAmount>, amount: Long): Boolean {
        val minimum = constraint.longValue().orElseThrow()
        return if (constraint.booleanValue("inclusive").orElse(false)) amount >= minimum else amount > minimum
    }

    private fun expression(elContext: CompiledELContext, text: String, expectedType: Class<*>): ValueExpression =
        expressions.computeIfAbsent(text) { key ->
            ELManager.getExpressionFactory().createValueExpression(elContext, key, expectedType) // (4)
        }
}

package example

import io.micronaut.aop.InterceptorBean
import io.micronaut.aop.MethodInterceptor
import io.micronaut.aop.MethodInvocationContext
import io.micronaut.el.CompiledELContext
import io.micronaut.core.annotation.AnnotationValue
import io.micronaut.core.type.Argument
import io.micronaut.el.example.eligible.ConstraintMessages
import io.micronaut.el.example.eligible.Eligible
import io.micronaut.el.example.eligible.MinAmount
import jakarta.el.ELManager
import jakarta.el.ValueExpression
import jakarta.inject.Singleton

import java.util.concurrent.ConcurrentHashMap

@Singleton
@InterceptorBean(Eligible) // (1)
class EligibleInterceptor implements MethodInterceptor<Object, Object> {

    private final Map<String, ValueExpression> expressions = new ConcurrentHashMap<>()

    @Override
    Object intercept(MethodInvocationContext<Object, Object> context) {
        CompiledELContext elContext = new CompiledELContext()
        context.parameterValueMap.each { name, value -> elContext.setBean(name, value) } // (2)

        for (Argument<?> argument : context.arguments) { // (5)
            AnnotationValue<MinAmount> constraint = argument.annotationMetadata.getAnnotation(MinAmount)
            Object value = context.parameterValueMap[argument.name]
            if (constraint != null && value instanceof Number && !satisfies(constraint, ((Number) value).longValue())) {
                throw new NotEligibleException(ConstraintMessages.interpolate(constraint, value)) // (6)
            }
        }

        String condition = context.stringValue(Eligible).orElseThrow() // (3)
        if (expression(elContext, condition, Boolean).getValue(elContext) == Boolean.TRUE) {
            return context.proceed()
        }
        String otherwise = context.stringValue(Eligible, "otherwise").orElse("")
        String message = otherwise.isEmpty()
            ? "${context.methodName} requires ${condition}".toString()
            : expression(elContext, otherwise, String).getValue(elContext)
        throw new NotEligibleException(message)
    }

    private static boolean satisfies(AnnotationValue<MinAmount> constraint, long amount) {
        long minimum = constraint.longValue().orElseThrow()
        constraint.booleanValue("inclusive").orElse(false) ? amount >= minimum : amount > minimum
    }

    private ValueExpression expression(CompiledELContext elContext, String text, Class<?> expectedType) {
        expressions.computeIfAbsent(text) { key ->
            ELManager.expressionFactory.createValueExpression(elContext, key, expectedType) // (4)
        }
    }
}

package example;

import io.micronaut.context.ApplicationContext;
import jakarta.el.ValueExpression;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

class EligibleTest {

    @Test
    void theConditionGuardsTheMethod() {
        try (ApplicationContext context = ApplicationContext.run()) {
            RegistrationService service = context.getBean(RegistrationService.class);

            assertEquals("registered Ann", service.register(new Customer("Ann", 34, "CZ"))); // (1)
            NotEligibleException rejected = assertThrows(NotEligibleException.class,
                () -> service.register(new Customer("Bob", 15, "CZ")));
            assertEquals("Bob must be an adult in Europe", rejected.getMessage()); // (2)

            assertEquals("deposited 100 for Ann", service.deposit(new Customer("Ann", 34, "DE"), 100));
            NotEligibleException tooSmall = assertThrows(NotEligibleException.class,
                () -> service.deposit(new Customer("Ann", 34, "DE"), 99));
            assertEquals("Must be greater than or equal to 100", tooSmall.getMessage()); // (4)
        }
    }

    @Test
    void theGeneratedConstantsCarryTheNameAndTheExpectedType() {
        ValueExpression condition = RegistrationService$ELExpressions.REGISTER; // (3)
        assertEquals(Boolean.class, condition.getExpectedType());
        ValueExpression otherwise = RegistrationService$ELExpressions.REGISTER_OTHERWISE;
        assertEquals(String.class, otherwise.getExpectedType());
    }
}

package example

import io.micronaut.context.ApplicationContext
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
import org.junit.jupiter.api.Test

class EligibleTest {

    @Test
    fun theConditionGuardsTheMethod() {
        ApplicationContext.run().use { context ->
            val service = context.getBean(RegistrationService::class.java)

            assertEquals("registered Ann", service.register(Customer("Ann", 34, "CZ"))) // (1)
            val rejected = assertThrows(NotEligibleException::class.java) {
                service.register(Customer("Bob", 15, "CZ"))
            }
            assertEquals("Bob must be an adult in Europe", rejected.message) // (2)

            assertEquals("deposited 100 for Ann", service.deposit(Customer("Ann", 34, "DE"), 100))
            val tooSmall = assertThrows(NotEligibleException::class.java) {
                service.deposit(Customer("Ann", 34, "DE"), 99)
            }
            assertEquals("Must be greater than or equal to 100", tooSmall.message) // (4)
        }
    }

    @Test
    fun theGeneratedConstantsCarryTheNameAndTheExpectedType() {
        val condition = `RegistrationService$ELExpressions`.REGISTER // (3)
        assertEquals(Boolean::class.javaObjectType, condition.expectedType)
        val otherwise = `RegistrationService$ELExpressions`.REGISTER_OTHERWISE
        assertEquals(String::class.java, otherwise.expectedType)
    }
}

package example

import io.micronaut.context.ApplicationContext
import io.micronaut.el.CompiledELContext
import jakarta.el.ELContext
import jakarta.el.ELManager
import jakarta.el.ValueExpression
import org.junit.jupiter.api.Test

import static org.junit.jupiter.api.Assertions.assertEquals
import static org.junit.jupiter.api.Assertions.assertThrows

class EligibleTest {

    @Test
    void theConditionGuardsTheMethod() {
        ApplicationContext.run().withCloseable { context ->
            RegistrationService service = context.getBean(RegistrationService)

            assertEquals("registered Ann", service.register(new Customer("Ann", 34, "CZ"))) // (1)
            NotEligibleException rejected = assertThrows(NotEligibleException) {
                service.register(new Customer("Bob", 15, "CZ"))
            }
            assertEquals("Bob must be an adult in Europe", rejected.message) // (2)

            assertEquals("deposited 100 for Ann", service.deposit(new Customer("Ann", 34, "DE"), 100))
            NotEligibleException tooSmall = assertThrows(NotEligibleException) {
                service.deposit(new Customer("Ann", 34, "DE"), 99)
            }
            assertEquals("Must be greater than or equal to 100", tooSmall.message) // (4)
        }
    }

    @Test
    void theExpressionsCarryTheExpectedType() {
        ELContext context = new CompiledELContext()
        ValueExpression condition = ELManager.expressionFactory.createValueExpression(context,
            '#{ fn:adult(customer.age) && fn:inEurope(customer.country) }', Boolean) // (3)
        assertEquals(Boolean, condition.expectedType)
    }
}