public interface AdminCommandHandler<C extends Command> {
    void execute(C command) throws ExecutionException;
}

public interface Command {
}

@ApplicationScoped
public class ClearCacheAdminCommandHandlerWithCommandToEnhance implements AdminCommandHandler<ClearCacheCommandToEnhance> {
    private final ClearCacheExecutor clearCacheExecutor;

    public ClearCacheAdminCommandHandlerWithCommandToEnhance(final ClearCacheExecutor clearCacheExecutor) {
        this.clearCacheExecutor = Objects.requireNonNull(clearCacheExecutor);
    }

    @Override
    public void execute(final ClearCacheCommandToEnhance command) throws ExecutionException {
        clearCacheExecutor.clear(command.cacheName);
    }
}

public class ClearCacheCommandToEnhance implements Command {
    @FormParam("cacheName")
    public String cacheName;
}

@Path("/admin")
public class ClearCacheAdminCommandHandlerEndpointToGenerate {
    private final ClearCacheAdminCommandHandlerWithCommandToEnhance adminCommandHandler;

    public ClearCacheAdminCommandHandlerEndpointToGenerate(
            final ClearCacheAdminCommandHandlerWithCommandToEnhance clearCacheAdminCommandHandlerWithCommandToEnhance) {
        this.adminCommandHandler = clearCacheAdminCommandHandlerWithCommandToEnhance;
    }

    @POST
    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    @Path("/clearCacheAdminCommandHandler")
    public void execute(@BeanParam final ClearCacheCommandToEnhance command) {
        adminCommandHandler.execute(command);
    }
}

@ApplicationScoped
public class ClearCacheAdminCommandHandler implements AdminCommandHandler<ClearCacheCommand> {
    private final ClearCacheExecutor clearCacheExecutor;

    public ClearCacheAdminCommandHandlerWithCommand(final ClearCacheExecutor clearCacheExecutor) {
        this.clearCacheExecutor = Objects.requireNonNull(clearCacheExecutor);
    }

    @Override
    public void execute(final ClearCacheCommand command) throws ExecutionException {
        clearCacheExecutor.clear(command.cacheName);
    }
}

public class ClearCacheCommandToEnhance implements Command {
    public String cacheName;
}

@BuildStep
    List<CommandHandlerDiscoveredBuildItem> discoverCommandHandlers(final ApplicationIndexBuildItem applicationIndexBuildItem) {
        final Class<?> adminCommandHandlerClazz = AdminCommandHandler.class;
        final Index index = applicationIndexBuildItem.getIndex();
        return index
                .getAllKnownImplementors(adminCommandHandlerClazz)
                .stream()
                .map(implementor -> {
                    final List<DotName> interfaceDotNames = implementor.interfaceNames();
                    final int position = IntStream.range(0, interfaceDotNames.size())
                            .filter(idx -> adminCommandHandlerClazz.getName().equals(interfaceDotNames.get(idx).toString()))
                            .findFirst()
                            .orElseThrow(() -> new IllegalStateException("Should not be here"));
                    final ParameterizedType adminCommandHandlerType = implementor.interfaceTypes().get(position)
                            .asParameterizedType();
                    final Type first = adminCommandHandlerType.arguments().getFirst();
                    final ClassInfo command = index.getClassByName(first.name());
                    return new CommandHandlerDiscoveredBuildItem(implementor, command);
                })
                .toList();
    }

    @BuildStep
    void generateAdminEndpoints(final List<CommandHandlerDiscoveredBuildItem> commandHandlerDiscoveredBuildItems,
                                final BuildProducer<GeneratedJaxRsResourceBuildItem> generatedJaxRsResourceBuildItemsProducer) {
        commandHandlerDiscoveredBuildItems.forEach(commandHandlerDiscoveredBuildItem -> {
            final String className = commandHandlerDiscoveredBuildItem.commandHandler().simpleName() + "EndpointGenerated";
            try (final ClassCreator beanClassCreator = ClassCreator.builder()
                    .classOutput(new GeneratedJaxRsResourceGizmoAdaptor(generatedJaxRsResourceBuildItemsProducer))
                    .className(className)
                    .setFinal(false)
                    .build()) {
                beanClassCreator.addAnnotation(Path.class).add("value", "/admin");

                final FieldCreator adminCommandHandlerField = beanClassCreator
                        .getFieldCreator("adminCommandHandler", AdminCommandHandler.class)
                        .setModifiers(ACC_PRIVATE | ACC_FINAL);

                final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
                final Class<?> commandHandlerClazz = contextClassLoader
                        .loadClass(commandHandlerDiscoveredBuildItem.commandHandler().name().toString());
                final Class<?> commandClazz = contextClassLoader
                        .loadClass(commandHandlerDiscoveredBuildItem.command().name().toString());
                // constructor
                try (final MethodCreator constructorMethod = beanClassCreator.getMethodCreator(MethodDescriptor.INIT,
                        void.class, commandHandlerClazz)) {
                    constructorMethod.setModifiers(ACC_PUBLIC);
                    constructorMethod.invokeSpecialMethod(MethodDescriptor.ofConstructor(Object.class),
                            constructorMethod.getThis());
                    constructorMethod.writeInstanceField(adminCommandHandlerField.getFieldDescriptor(),
                            constructorMethod.getThis(), constructorMethod.getMethodParam(0));
                    constructorMethod.returnVoid();
                }

                // execute method
                try (final MethodCreator executeMethod = beanClassCreator.getMethodCreator("execute", void.class,
                        commandClazz)) {
                    executeMethod.setModifiers(ACC_PUBLIC);

                    executeMethod.addAnnotation(POST.class);
                    executeMethod.addAnnotation(Consumes.class).add("value",
                            new String[]{MediaType.APPLICATION_FORM_URLENCODED});
                    executeMethod.addAnnotation(Path.class).add("value",
                            endpointNaming(commandHandlerDiscoveredBuildItem.commandHandler().simpleName()));

                    executeMethod.getParameterAnnotations(0).addAnnotation(BeanParam.class);

                    final ResultHandle commandHandlerResult = executeMethod
                            .readInstanceField(adminCommandHandlerField.getFieldDescriptor(), executeMethod.getThis());
                    executeMethod
                            .invokeVirtualMethod(
                                    MethodDescriptor.ofMethod(commandHandlerClazz, "execute",
                                            void.class, commandHandlerDiscoveredBuildItem.command().name().toString()),
                                    commandHandlerResult, executeMethod.getMethodParam(0));

                    executeMethod.returnVoid();
                }
                beanClassCreator.writeTo((name, bytes) -> {
                    // for debugging purpose:  open the file with IntelliJ to see the class generated
                    final File file = new File(String.format("target/%s.class", name));
                    try (FileOutputStream outputStream = new FileOutputStream(file)) {
                        outputStream.write(bytes);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                });
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
        });
    }

    @BuildStep
    AnnotationsTransformerBuildItem bindCommandFieldsWithJaxRSFormParam(final ApplicationIndexBuildItem applicationIndexBuildItem) {
        final List<ClassInfo> commandImplementors = applicationIndexBuildItem.getIndex()
                .getAllKnownImplementors(Command.class)
                .stream().toList();
        return new AnnotationsTransformerBuildItem(AnnotationTransformation.forFields()
                .whenField(fieldInfo -> commandImplementors.contains(fieldInfo.declaringClass()))
                .transform(transformationContext -> {
                    transformationContext.add(AnnotationInstance.builder(FormParam.class)
                            .add("value", transformationContext.declaration().asField().name())
                            .build());
                })
        );
    }
}

public final class CommandHandlerDiscoveredBuildItem extends MultiBuildItem {
    private final ClassInfo commandHandler;
    private final ClassInfo command;

    public CommandHandlerDiscoveredBuildItem(final ClassInfo commandHandler, ClassInfo command) {
        this.commandHandler = Objects.requireNonNull(commandHandler);
        this.command = Objects.requireNonNull(command);
    }

    public ClassInfo commandHandler() {
        return commandHandler;
    }

    public ClassInfo command() {
        return command;
    }
}

@Override
    protected boolean handleBeanParam(ClassInfo actualEndpointInfo, Type paramType, MethodParameter[] methodParameters, int i,
            Set<String> fileFormNames) {
        ClassInfo beanParamClassInfo = index.getClassByName(paramType.name());
        InjectableBean injectableBean = scanInjectableBean(beanParamClassInfo,
                actualEndpointInfo,
                existingConverters, additionalReaders, injectableBeans, hasRuntimeConverters);
        if ((injectableBean.getFieldExtractorsCount() == 0) && !injectableBean.isInjectionRequired()) {
            throw new DeploymentException(String.format("No annotations found on fields at '%s'. "
                    + "Annotations like `@QueryParam` should be used in fields, not in methods.",
                    beanParamClassInfo.name()));
        }
        fileFormNames.addAll(injectableBean.getFileFormNames());
        return injectableBean.isFormParamRequired();
    }

ClassInfo beanParamClassInfo = index.getClassByName(paramType.name());