rework command system

src/main/java/cc/fascinated/bat/command/BatCommand.java

@@ -1,103 +1,124 @@
 package cc.fascinated.bat.command;
 
 import cc.fascinated.bat.features.Feature;
+import cc.fascinated.bat.model.BatGuild;
+import cc.fascinated.bat.model.BatUser;
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NonNull;
 import lombok.Setter;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
 import net.dv8tion.jda.api.interactions.IntegrationType;
 import net.dv8tion.jda.api.interactions.InteractionContextType;
-import net.dv8tion.jda.api.interactions.commands.OptionMapping;
-import net.dv8tion.jda.api.interactions.commands.OptionType;
 import net.dv8tion.jda.api.interactions.commands.SlashCommandInteraction;
+import net.dv8tion.jda.api.interactions.commands.build.OptionData;
+import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
 import net.dv8tion.jda.internal.interactions.CommandDataImpl;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
- * @author Fascinated (fascinated7)
+ * @author Braydon
  */
 @Getter
-@Setter
-public abstract class BatCommand implements BatCommandExecutor {
+public abstract class BatCommand {
     /**
-     * The information about the command
+     * The info of this command.
      */
-    private final CommandInfo commandInfo;
+    @NonNull private final InternalCommandInfo info;
 
     /**
-     * The command data for the slash command
+     * The feature this command belongs to.
      */
-    private final CommandDataImpl commandData;
+    @Setter private Feature feature;
 
     /**
-     * The sub commands of the command
+     * The snowflake of this command, set when
+     * this command is registered with Discord.
      */
-    private final Map<String, BatSubCommand> subCommands = new HashMap<>();
+    @Setter private long snowflake;
 
     /**
-     * The category of the command
+     * The sub commands of this command, if any.
      */
-    private Category category;
+    private final Map<String, BatCommand> subCommands = Collections.synchronizedMap(new HashMap<>());
 
     /**
-     * The feature that the command belongs to
+     * The internal data for this command.
      */
-    private Feature feature;
+    @Setter(AccessLevel.PRIVATE) private CommandDataImpl commandData;
 
     /**
-     * Whether the command can only be used by the bot owner
+     * The internal subcommand data for this command.
      */
-    private boolean botOwnerOnly;
-
-    /**
-     * The command snowflake from Discord
-     */
-    private long commandSnowflake;
+    @Setter(AccessLevel.PRIVATE) private SubcommandData subcommandData;
 
     public BatCommand() {
-        this.commandInfo = getClass().getAnnotation(CommandInfo.class);
-        this.category = this.commandInfo.category();
-        this.botOwnerOnly = this.commandInfo.botOwnerOnly();
+        if (!getClass().isAnnotationPresent(CommandInfo.class)) {
+            throw new IllegalStateException("Missing @CommandInfo annotation in " + getClass().getSimpleName());
+        }
+        info = new InternalCommandInfo(getClass().getAnnotation(CommandInfo.class));
 
-        List<IntegrationType> integrationTypes = this.commandInfo.userInstall() ? List.of(IntegrationType.GUILD_INSTALL, IntegrationType.USER_INSTALL) :
-                List.of(IntegrationType.GUILD_INSTALL);
-        this.commandData = new CommandDataImpl(this.commandInfo.name(), this.commandInfo.description())
-                .setGuildOnly(this.commandInfo.guildOnly())
+        List<IntegrationType> integrationTypes = new ArrayList<>(Collections.singletonList(IntegrationType.GUILD_INSTALL));
+        if (info.isUserInstall()) {
+            integrationTypes.add(IntegrationType.USER_INSTALL);
+        }
+        commandData = new CommandDataImpl(info.getName(), info.getDescription())
                 .setContexts(InteractionContextType.ALL)
-                .setIntegrationTypes(integrationTypes);
+                .setIntegrationTypes(integrationTypes)
+                .setGuildOnly(info.isGuildOnly());
     }
 
     /**
-     * Adds a sub command to the command
+     * Fired when this command is executed.
      *
-     * @param subCommand The sub command
+     * @param guild the guild the command was executed in, if any
+     * @param user the user who executed the command
+     * @param channel the channel the command was executed in
+     * @param member the member who executed the command, null if not a guild
+     * @param event the event that invoked this command
      */
-    public void addSubCommand(@NonNull BatSubCommand subCommand) {
-        this.subCommands.put(subCommand.getCommandInfo().name().toLowerCase(), subCommand);
-        this.commandData.addSubcommands(subCommand.getCommandData());
+    public void execute(BatGuild guild, @NonNull BatUser user, @NonNull MessageChannel channel, Member member, @NonNull SlashCommandInteraction event) { }
+
+    /**
+     * Register the given sub commands.
+     *
+     * @param commands the commands to register
+     */
+    protected final void addSubCommands(@NonNull BatCommand... commands) {
+        for (BatCommand command : commands) {
+            // Copy info from the parent command
+            if (command.getInfo().getCategory() != info.getCategory()) {
+                command.getInfo().setCategory(info.getCategory());
+            }
+            if (command.getInfo().getPermissions().length == 0) {
+                command.getInfo().setPermissions(info.getPermissions());
+            }
+            if (command.getInfo().isGuildOnly() != info.isGuildOnly()) {
+                command.getInfo().setGuildOnly(info.isGuildOnly());
+            }
+            if (command.getInfo().isBotOwnerOnly() != info.isBotOwnerOnly()) {
+                command.getInfo().setBotOwnerOnly(info.isBotOwnerOnly());
+            }
+
+            command.setSubcommandData(new SubcommandData(command.getInfo().getName(), command.getInfo().getDescription()));
+            commandData.addSubcommands(command.getSubcommandData());
+            subCommands.put(command.getInfo().getName(), command);
+        }
     }
 
     /**
-     * Adds an option to the sub command
+     * Add the given options
+     * to this command.
      *
-     * @param optionType  the type of the option
-     * @param name        the name of the option
-     * @param description the description of the option
-     * @param required    whether the option is required
+     * @param options the options to add
      */
-    protected void addOption(OptionType optionType, String name, String description, boolean required) {
-        this.commandData.addOption(optionType, name, description, required);
+    protected final void addOptions(OptionData... options) {
+        if (subcommandData != null) {
+            subcommandData.addOptions(options);
+        } else {
+            commandData.addOptions(options);
+        }
     }
-
-    /**
-     * Gets all the options for the command
-     *
-     * @param interaction The slash command interaction
-     * @return The option strings
-     */
-    public List<String> getOptions(SlashCommandInteraction interaction) {
-        return interaction.getOptions().stream().map(OptionMapping::getName).toList();
-    }
-}
+}