add definition parameter to wrapper register method

lib/src/main/java/net/tomatentum/marinara/interaction/commands/ApplicationCommandDefinition.java

@@ -3,18 +3,54 @@ package net.tomatentum.marinara.interaction.commands;
 import java.util.ArrayList;
 import java.util.List;
 
-public record ApplicationCommandDefinition(
+import net.tomatentum.marinara.interaction.commands.annotation.ApplicationCommand;
-    List<ExecutableCommandDefinition> executableDefinitons,
-    String applicationCommand
-) {
 
-    public ApplicationCommandDefinition(String applicationCommand) {
+public class ApplicationCommandDefinition {
-        this(new ArrayList<>(), applicationCommand);
+    private List<ExecutableCommandDefinition> executableDefinitons;
+    private ApplicationCommand applicationCommand;
+    private int subCommandGroupCount = -1;
+    private boolean isRootCommand = false;
+
+    public ApplicationCommandDefinition(ApplicationCommand applicationCommand) {
+        this.executableDefinitons = new ArrayList<>();
+        this.applicationCommand = applicationCommand;
     }
 
     public ApplicationCommandDefinition addExecutableCommand(ExecutableCommandDefinition def) {
+        if (this.subCommandGroupCount == -1)
+            this.subCommandGroupCount = def.subCommandGroups().length;
+        if (def.subCommandGroups().length != subCommandGroupCount)
+            throw new IllegalArgumentException(def + ": has a non matching amount of subcommand groups. All subcommands must have the same amount of subcommand groups!");
+        if (def.applicationCommand() != null) {
+            if (applicationCommand == null)
+                this.applicationCommand = def.applicationCommand();
+            if (!this.applicationCommand.equals(def.applicationCommand()))
+                throw new IllegalArgumentException(def + ": has a non matching Application Command description. Please edit it to equal all other descriptions or remove it to use other definitions descriptions");
+        }
+        if (isRootCommand) {
+            if (!def.isRootCommand())
+                throw new IllegalArgumentException(def + ": cannot have subcommands and rootcommand definitions together");
+            long subCommandAmount = executableDefinitons.stream()
+                .filter((x) -> !x.isRootCommand())
+                .count();
+            if (subCommandAmount > 0)
+                throw new IllegalArgumentException(def + ": cannot have subcommands and rootcommand definitions together");
+        }
+        
         executableDefinitons.add(def);
         return this;
     }
 
+    public ApplicationCommand getApplicationCommand() {
+        return applicationCommand;
+    }
+
+    public List<ExecutableCommandDefinition> getExecutableDefinitons() {
+        return executableDefinitons;
+    }
+
+    public int getSubCommandGroupCount() {
+        return subCommandGroupCount;
+    }
+
 }

lib/src/main/java/net/tomatentum/marinara/interaction/commands/ExecutableCommandDefinition.java

@@ -1,15 +1,13 @@
 package net.tomatentum.marinara.interaction.commands;
 
-import org.apache.logging.log4j.core.tools.picocli.CommandLine.Command;
+import net.tomatentum.marinara.interaction.commands.annotation.ApplicationCommand;
-
 import net.tomatentum.marinara.interaction.commands.annotation.CommandOption;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
 
 public record ExecutableCommandDefinition(
-    String applicationCommand,
+    ApplicationCommand applicationCommand,
-    String applicationCommandDescription, 
+    SubCommand subCommand,
     String[] subCommandGroups, 
-    String subCommand, 
-    String subCommandDescription,
     CommandOption[] options) {
 
     @Override
@@ -22,71 +20,54 @@ public record ExecutableCommandDefinition(
             other.subCommand.equals(this.subCommand);
     }
 
+    @Override
+    public final String toString() {
+        return applicationCommand.name() + subCommand.name() != null ? "::" + subCommand.name() : "";
+    }
+
+    public boolean isRootCommand() {
+        return subCommand == null;    
+    }
+
     public static class Builder {
-        private String applicationCommandName;
+        private ApplicationCommand applicationCommand;
-        private String applicationCommandDescription;
+        private SubCommand subCommand;
         private String[] subCommandGroupNames;
-        private String subCommandName;
-        private String subCommandDescription;
-        public CommandOption[] options;
 
         public Builder() {
             this.subCommandGroupNames = new String[0];
         }
 
         public ExecutableCommandDefinition build() {
-            if (applicationCommandName == null)
+            if (applicationCommand == null)
                 throw new IllegalArgumentException("applicationCommandName cant be null");
 
-            return new ExecutableCommandDefinition(applicationCommandName, applicationCommandDescription, subCommandGroupNames, subCommandName, subCommandDescription, options);
+            return new ExecutableCommandDefinition(applicationCommand, subCommand, subCommandGroupNames, subCommand != null ? subCommand.options() : applicationCommand.options());
         }
 
-        public void setApplicationCommandName(String applicationCommandName) {
+        public void setApplicationCommand(ApplicationCommand applicationCommand) {
-            this.applicationCommandName = applicationCommandName;
+            this.applicationCommand = applicationCommand;
         }
 
-        public void setApplicationCommandDescription(String applicationCommandDescription) {
+        public void setSubCommand(SubCommand subCommand) {
-            this.applicationCommandDescription = applicationCommandDescription;
+            this.subCommand = subCommand;
         }
 
         public void setSubCommandGroupNames(String[] subCommandGroupNames) {
             this.subCommandGroupNames = subCommandGroupNames;
         }
 
-        public void setSubCommandName(String subCommandName) {
+        public ApplicationCommand getApplicationCommand() {
-            this.subCommandName = subCommandName;
+            return applicationCommand;
         }
 
-        public void setSubCommandDescription(String subCommandDescription) {
+        public SubCommand getSubCommand() {
-            this.subCommandDescription = subCommandDescription;
+            return subCommand;
-        }
-
-        public void setOptions(CommandOption[] options) {
-            this.options = options;
-        }
-
-        public String getApplicationCommandName() {
-            return applicationCommandName;
-        }
-
-        public String getApplicationCommandDescription() {
-            return applicationCommandDescription;
         }
 
         public String[] getSubCommandGroupNames() {
             return subCommandGroupNames;
         }
 
-        public String getSubCommandName() {
-            return subCommandName;
-        }
-
-        public String getSubCommandDescription() {
-            return subCommandDescription;
-        }
-
-        public CommandOption[] getOptions() {
-            return options;
-        }
     }
 }

lib/src/main/java/net/tomatentum/marinara/interaction/methods/CommandInteractionMethod.java

@@ -46,9 +46,7 @@ public class CommandInteractionMethod extends InteractionMethod {
 
         ApplicationCommand cmd = ReflectionUtil.getAnnotation(method, ApplicationCommand.class);
         ExecutableCommandDefinition.Builder builder = new ExecutableCommandDefinition.Builder();
-        builder.setApplicationCommandName(cmd.name());
+        builder.setApplicationCommand(cmd);
-        builder.setApplicationCommandDescription(cmd.description());
-        builder.setOptions(parseOptions());
 
         if (ReflectionUtil.isAnnotationPresent(method, SubCommandGroup.class)) {
             SubCommandGroup cmdGroup = ReflectionUtil.getAnnotation(method, SubCommandGroup.class);
@@ -57,21 +55,10 @@ public class CommandInteractionMethod extends InteractionMethod {
 
         if (ReflectionUtil.isAnnotationPresent(method, SubCommand.class)) {
             SubCommand subCmd = ReflectionUtil.getAnnotation(method, SubCommand.class);
-            builder.setSubCommandName(subCmd.name());
+            builder.setSubCommand(subCmd);
-            builder.setSubCommandDescription(subCmd.description());
         }
 
         this.commandDefinition = builder.build();
     }
 
-    private CommandOption[] parseOptions() {
-        if (method.isAnnotationPresent(SubCommand.class)) {
-            SubCommand subCmd = method.getAnnotation(SubCommand.class);
-            return subCmd.options();
-        }else {
-            ApplicationCommand subCmd = method.getAnnotation(ApplicationCommand.class);
-            return subCmd.options();
-        }
-    }
-
 }

lib/src/main/java/net/tomatentum/marinara/registry/InteractionRegistry.java

@@ -37,7 +37,7 @@ public class InteractionRegistry {
 
         execDefs.forEach((def) -> {
             Optional<ApplicationCommandDefinition> appDef = defs.stream()
-                .filter((x) -> x.applicationCommand().equals(def.applicationCommand()))
+                .filter((x) -> x.getApplicationCommand().equals(def.applicationCommand()))
                 .findFirst();
             if (appDef.isPresent())
                 appDef.get().addExecutableCommand(def);

lib/src/main/java/net/tomatentum/marinara/wrapper/LibraryWrapper.java

@@ -4,6 +4,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
 
+import net.tomatentum.marinara.interaction.commands.ApplicationCommandDefinition;
 import net.tomatentum.marinara.interaction.commands.ExecutableCommandDefinition;
 import net.tomatentum.marinara.interaction.commands.option.OptionType;
 import net.tomatentum.marinara.interaction.InteractionType;
@@ -16,8 +17,8 @@ public abstract class LibraryWrapper {
         interactionSubscriber = new ArrayList<>();
     }
 
-    public abstract void registerGlobalCommand(); 
+    public abstract void registerGlobalCommand(ApplicationCommandDefinition def); 
-    public abstract void registerServerCommand();
+    public abstract void registerServerCommand(ApplicationCommandDefinition def);
 
     public void handleInteraction(Object context) {
         interactionSubscriber.forEach((o) -> o.accept(context));