Added support for slash command loading into :annotations module

Author: surajkumar

annotations/src/main/java/com/javadiscord/jdi/core/CommandOptionType.java

@@ -0,0 +1,26 @@
+package com.javadiscord.jdi.core;
+
+public enum CommandOptionType {
+    SUB_COMMAND(1),
+    SUB_COMMAND_GROUP(2),
+    STRING(3),
+    INTEGER(4),
+    BOOLEAN(5),
+    USER(6),
+    CHANNEL(7),
+    ROLE(8),
+    MENTIONABLE(9),
+    NUMBER(10),
+    ATTACHMENT(11),
+    ;
+
+    private final int value;
+
+    CommandOptionType(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

annotations/src/main/java/com/javadiscord/jdi/core/annotations/CommandOption.java

@@ -0,0 +1,19 @@
+package com.javadiscord.jdi.core.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import com.javadiscord.jdi.core.CommandOptionType;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({})
+public @interface CommandOption {
+    String name();
+
+    String description();
+
+    CommandOptionType type();
+
+    boolean required() default true;
+}

annotations/src/main/java/com/javadiscord/jdi/core/annotations/SlashCommand.java

@@ -0,0 +1,16 @@
+package com.javadiscord.jdi.core.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface SlashCommand {
+    String name();
+
+    String description();
+
+    CommandOption[] options() default {};
+}

annotations/src/main/java/com/javadiscord/jdi/core/processor/SlashCommandClassMethod.java

@@ -0,0 +1,5 @@
+package com.javadiscord.jdi.core.processor;
+
+import java.lang.reflect.Method;
+
+public record SlashCommandClassMethod(Class<?> clazz, Method method) {}

annotations/src/main/java/com/javadiscord/jdi/core/processor/SlashCommandLoader.java

@@ -0,0 +1,90 @@
+package com.javadiscord.jdi.core.processor;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Map;
+
+import com.javadiscord.jdi.core.annotations.SlashCommand;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class SlashCommandLoader {
+    private static final Logger LOGGER = LogManager.getLogger(SlashCommandLoader.class);
+    private final Map<String, SlashCommandClassMethod> interactionListeners;
+    private final SlashCommandValidator validator = new SlashCommandValidator();
+
+    public SlashCommandLoader(Map<String, SlashCommandClassMethod> interactionListeners) {
+        this.interactionListeners = interactionListeners;
+        loadInteractionListeners();
+    }
+
+    private void loadInteractionListeners() {
+        List<File> classes = ClassFileUtil.getClassesInClassPath();
+        for (File classFile : classes) {
+            try {
+
+                String name = ClassFileUtil.getClassName(classFile);
+                if(name.contains("io.netty")
+                        || name.contains("org.apache")
+                        || name.contains("io.vertx")
+                        || name.contains("com.fasterxml")) {
+                    continue;
+                }
+
+                Class<?> clazz = Class.forName(name);
+
+                Method[] methods = clazz.getMethods();
+                for (Method method : methods) {
+                    if (method.getAnnotation(SlashCommand.class) != null) {
+                        if (validator.validate(method) && hasZeroArgsConstructor(clazz)) {
+                            registerListener(
+                                clazz, method, method.getAnnotation(SlashCommand.class).name()
+                            );
+                        } else {
+                            LOGGER.error("{} failed validation", method.getName());
+                        }
+                    }
+                }
+            } catch (Exception | Error ignore) {
+                /* Ignore */
+            }
+        }
+    }
+
+    private void registerListener(Class<?> clazz, Method method, String name) {
+        try {
+            if (interactionListeners.containsKey(name)) {
+                LOGGER.error(
+                    "Failed to register command {} from {} as that name already exists in {}",
+                    name,
+                    clazz.getName(),
+                    interactionListeners.get(name).getClass().getName()
+                );
+                return;
+            }
+            interactionListeners.put(name, new SlashCommandClassMethod(clazz, method));
+            LOGGER.info("Found slash command handler {}", clazz.getName());
+        } catch (Exception e) {
+            LOGGER.error("Failed to create {} instance", clazz.getName(), e);
+        }
+    }
+
+    public SlashCommandClassMethod getSlashCommandClassMethod(String name) {
+        return interactionListeners.get(name);
+    }
+
+    private boolean hasZeroArgsConstructor(Class<?> clazz) {
+        Constructor<?>[] constructors = clazz.getConstructors();
+        for (Constructor<?> constructor : constructors) {
+            if (constructor.getParameterCount() == 0) {
+                return true;
+            }
+        }
+        LOGGER.error("{} does not have a 0 arg constructor", clazz.getName());
+        return false;
+    }
+
+}

annotations/src/main/java/com/javadiscord/jdi/core/processor/SlashCommandValidator.java

@@ -0,0 +1,60 @@
+package com.javadiscord.jdi.core.processor;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.javadiscord.jdi.core.annotations.SlashCommand;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class SlashCommandValidator {
+    private static final Logger LOGGER = LogManager.getLogger(SlashCommandValidator.class);
+    private static final Map<Class<? extends Annotation>, String[]> EXPECTED_PARAM_TYPES_MAP =
+        new HashMap<>();
+
+    static {
+        EXPECTED_PARAM_TYPES_MAP.put(
+            SlashCommand.class,
+            new String[] {
+                "com.javadiscord.jdi.core.models.guild.Interaction",
+                "com.javadiscord.jdi.core.Discord",
+                "com.javadiscord.jdi.core.Guild"
+            }
+        );
+    }
+
+    public boolean validate(Method method) {
+        for (Map.Entry<Class<? extends Annotation>, String[]> entry : EXPECTED_PARAM_TYPES_MAP
+            .entrySet()) {
+            Class<? extends Annotation> annotationClass = entry.getKey();
+            if (method.isAnnotationPresent(annotationClass)) {
+                String[] expectedParamTypes = entry.getValue();
+                if (method.getParameterCount() > 0) {
+                    Class<?>[] paramTypes = method.getParameterTypes();
+                    for (Class<?> type : paramTypes) {
+                        boolean isExpectedType = false;
+                        for (String expectedType : expectedParamTypes) {
+                            if (type.getName().equals(expectedType)) {
+                                isExpectedType = true;
+                                break;
+                            }
+                        }
+                        if (!isExpectedType) {
+                            LOGGER.error("Unexpected parameter found: {}", type.getName());
+                            return false;
+                        }
+                    }
+                } else if (method.getParameterCount() != 0) {
+                    LOGGER.error(
+                        "{} does not have the expected parameter types", method.getName()
+                    );
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}