Fixed so you can register several main/root commands correcly

Now will it have option register own main commands with own sub commands.

Author: broken1arrow

Commands/src/main/java/org/broken/arrow/library/command/CommandRegister.java

@@ -4,30 +4,41 @@
 import org.broken.arrow.library.command.command.CommandProperty;
 import org.broken.arrow.library.command.commandhandler.CommandExecutor;
 import org.broken.arrow.library.command.commandhandler.CommandRegistering;
+import org.broken.arrow.library.command.commandhandler.MainCommandHandler;
+import org.broken.arrow.library.command.builers.CommandBuilder;
+import org.broken.arrow.library.command.subcommand.CommandDisplayConfig;
 import org.broken.arrow.library.logging.Logging;
 import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandException;
 import org.bukkit.command.CommandMap;
+import org.bukkit.plugin.Plugin;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Locale;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * A utility class for registering and managing registered commands.The commandRegister provides
  * methods for registering subcommands, setting command label messages and permissions,
  * retrieving sub-commands, and registering the main command label.
  */
 public class CommandRegister implements CommandRegistering {
-    private Logging log = new Logging(CommandRegister.class);
+    private final Logging log = new Logging(CommandRegister.class);
 
     private final List<CommandProperty> commands = Collections.synchronizedList(new ArrayList<>());
+    private final Map<String, MainCommandHandler> commandsNew = new ConcurrentHashMap<>();
+
     private String commandLabelMessage;
     private String commandLabelMessageNoPerms;
     private String commandLabelPermission;
@@ -43,7 +54,6 @@ public CommandRegistering registerSubCommand(final CommandProperty subCommand) {
         if (addCommands(subCommand, commandLabels)) {
             return this;
         }
-
         commands.removeIf(oldCommandBuilder -> oldCommandBuilder.equals(subCommand));
         commands.removeIf(oldCommandBuilder -> oldCommandBuilder.getCommandLabels().equals(subCommand.getCommandLabels()));
         commands.add(subCommand);
@@ -58,9 +68,49 @@ public CommandRegistering registerSubCommands(final CommandProperty... subComman
         for (CommandProperty registerSubCommand : subCommands) {
             this.registerSubCommand(registerSubCommand);
         }
+
+        registerCommand(null, "test")
+                .setAliases("before")
+                .registerSubCommandGroup(subCommand->{
+                    subCommand.registerSubCommand(null);
+                })
+                .display(displayConfig -> {
+                    displayConfig.setCommandLabelMessage("");
+                    displayConfig.setSuffixMessage("-----<suffix>-----");
+                    displayConfig.setPrefixMessage("-----<prefix>-----");
+                })
+                .setAliases("testings");
+
+        registerCommand(null, "testing")
+                .setMainDescription("something")
+                .setMainCommand(null)
+                .setMainDescription("a command");
         return this;
     }
 
+    /**
+     * Registers a new command entry point for this plugin.
+     *
+     * <p>This is the primary entry method for creating and configuring a command.
+     * It initializes the internal command handler and returns a {@link CommandBuilder}
+     * used to define aliases, subcommands, execution behavior, and display settings.</p>
+     *
+     * <p>The plugin name is used as a fallback namespace for command registration.</p>
+     *
+     * @param plugin the owning plugin instance (used for namespace and registration context)
+     * @param mainCommand the root command label (e.g. "plugin" in "/plugin menu")
+     * @return a {@link CommandBuilder} used to configure the command structure
+     */
+    public CommandBuilder registerCommand(final Plugin plugin, final String mainCommand) {
+        final CommandDisplayConfig commandDisplayConfig = new CommandDisplayConfig();
+        final MainCommandHandler mainCommandHandler = new MainCommandHandler(commandDisplayConfig);
+        final CommandBuilder commandBuilder = new CommandBuilder(mainCommandHandler);
+
+        commandsNew.put(mainCommand, mainCommandHandler);
+        this.registerMainCommand(plugin.getName().toLowerCase(Locale.ROOT), mainCommand, commandBuilder);
+        return commandBuilder;
+    }
+
     /**
      * Returns the message to display as the command label.
      *
@@ -260,6 +310,7 @@ public List<CommandProperty> getCommands() {
      * @param label The sub-label of the command builder to retrieve.
      * @return The command builder with the specified sub-label, or null if not found.
      */
+    @Nullable
     @Override
     public CommandProperty getCommandBuilder(String label) {
         return getCommandBuilder(label, false);
@@ -272,8 +323,11 @@ public CommandProperty getCommandBuilder(String label) {
      * @param startsWith Specifies whether the sub-label should match the beginning of the command builder's sub-label.
      * @return The command builder with the specified sub-label, or null if not found.
      */
+    @Nullable
     @Override
     public CommandProperty getCommandBuilder(String label, boolean startsWith) {
+        if (startsWith)
+            System.out.println("getCommandBuilder " + label);
         for (final CommandProperty command : commands) {
             if (startsWith && (label.isEmpty() || command.firstLabelMatch(label, true) != null))
                 return command;
@@ -310,6 +364,7 @@ public CommandRegistering registerMainCommand(String fallbackPrefix, String main
         return this.registerMainCommand(fallbackPrefix, mainCommand, "", "", aliases);
     }
 
+
     /**
      * Registers the main command with the specified fallback prefix, command, description, usage message, and aliases.
      * If the main command has already been registered, this method does nothing.
@@ -322,16 +377,14 @@ public CommandRegistering registerMainCommand(String fallbackPrefix, String main
      * @return The CommandRegistering instance.
      */
     @Override
-    public CommandRegistering registerMainCommand(String fallbackPrefix, String mainCommand, String description, String usageMessage, String... aliases) {
+    public CommandRegistering registerMainCommand(@Nonnull final String fallbackPrefix, @Nonnull final String mainCommand, @Nonnull final String description, @Nonnull final String usageMessage, @Nonnull final String... aliases) {
         final String[] main = mainCommand.split("\\|");
         if (registeredMainCommand) return this;
         if (main.length > 1)
             for (final String command : main)
                 this.register(fallbackPrefix, new CommandExecutor(this, command, description, usageMessage, Arrays.asList(aliases)));
         else
             this.register(fallbackPrefix, new CommandExecutor(this, mainCommand, description, usageMessage, Arrays.asList(aliases)));
-        registeredMainCommand = true;
-
         return this;
     }
 
@@ -350,6 +403,14 @@ public boolean addCommands(CommandProperty subCommand, Set<String> commandLabels
         }
     }
 
+    private void registerMainCommand(@Nonnull final String fallbackPrefix, @Nonnull final String mainCommand, @Nonnull final CommandBuilder commandBuilder) {
+        final String description = commandBuilder.getMainDescription();
+        final String usageMessage = commandBuilder.getMainUsageMessage();
+        final String[] aliases = commandBuilder.getAliases();
+        this.registerMainCommand(fallbackPrefix, mainCommand, description, usageMessage, aliases);
+    }
+
+
     /**
      * Registers the specified command with the provided fallback prefix.
      * This method uses reflection to access the commandMap and register the command.

Commands/src/main/java/org/broken/arrow/library/command/builers/CommandBuilder.java

@@ -0,0 +1,119 @@
+package org.broken.arrow.library.command.builers;
+
+import org.broken.arrow.library.command.command.CommandProperty;
+import org.broken.arrow.library.command.commandhandler.MainCommandHandler;
+import org.broken.arrow.library.logging.Validate;
+import org.bukkit.command.CommandException;
+
+import javax.annotation.Nonnull;
+import java.util.function.Consumer;
+
+/**
+ * Entry builder for defining a command structure, including optional subcommands,
+ * a single main command, and shared command metadata such as aliases, usage, and description.
+ *
+ * <p>This class represents the primary configuration stage of a command before it transitions
+ * into execution-specific or display configuration stages.</p>
+ */
+public class CommandBuilder extends CommandOptions {
+    private final MainCommandHandler mainCommandHandler;
+
+    /**
+     * Creates a new command builder tied to the given {@link MainCommandHandler}.
+     *
+     * @param mainCommandHandler internal handler responsible for managing command registration
+     */
+    public CommandBuilder(@Nonnull final MainCommandHandler mainCommandHandler) {
+        this.mainCommandHandler = mainCommandHandler;
+    }
+
+    /**
+     * Sets the command description.
+     *
+     * @param description human-readable description of the command
+     * @return this builder instance for chaining
+     */
+    @Override
+    public CommandBuilder setMainDescription(String description) {
+        super.setMainDescription(description);
+        return this;
+    }
+
+    /**
+     * Sets the usage message displayed when the command is used incorrectly or help is requested.
+     *
+     * @param usageMessage usage instruction string
+     * @return this builder instance for chaining
+     */
+    @Override
+    public CommandBuilder setMainUsageMessage(String usageMessage) {
+        super.setMainUsageMessage(usageMessage);
+        return this;
+    }
+
+    /**
+     * Defines alternative aliases for this command.
+     *
+     * @param aliases alternative command labels
+     * @return this builder instance for chaining
+     */
+    @Override
+    public CommandBuilder setAliases(String... aliases) {
+        super.setAliases(aliases);
+        return this;
+    }
+
+    /**
+     * Registers a group of subcommands using a configuration wrapper.
+     *
+     * <p>This method provides a structured way to define multiple subcommands
+     * within a single lambda scope, improving readability and reducing repeated calls.</p>
+     *
+     * <pre>{@code
+     * registerSubCommandGroup(wrapper -> {
+     *     wrapper.registerSubCommand(new ReloadCommand(...));
+     *     wrapper.registerSubCommand(new HelpCommand(...));
+     * });
+     * }</pre>
+     *
+     * @param consumer lambda receiving a {@link SubcommandWrapper} used to register subcommands
+     * @return a {@link CommandDisplayBuilder} to continue configuration (e.g. display settings)
+     * @throws CommandException if any subcommand has invalid or empty command labels
+     */
+    public CommandDisplayBuilder registerSubCommandGroup(@Nonnull final Consumer<SubcommandWrapper> consumer) {
+        final SubcommandWrapper subcommandWrapper = new SubcommandWrapper(mainCommandHandler);
+        consumer.accept(subcommandWrapper);
+        return new CommandDisplayBuilder(this, mainCommandHandler);
+    }
+
+    /**
+     * Registers one or more subcommands directly using varargs input.
+     *
+     * <p>This is a convenience method for quickly registering multiple subcommands
+     * without using a lambda-based configuration block.</p>
+     *
+     * @param subCommands subcommands to register (must not be null or empty)
+     * @return a {@link CommandDisplayBuilder} to continue configuration (e.g. display settings)
+     * @throws CommandException if any subcommand has invalid or empty command labels
+     * @throws Validate.ValidateExceptions if a main command has already been configured
+     */
+    public CommandDisplayBuilder registerSubCommands(final CommandProperty... subCommands) {
+        mainCommandHandler.registerSubCommands(subCommands);
+        return new CommandDisplayBuilder(this, mainCommandHandler);
+    }
+
+    /**
+     * Defines a single main command instead of using subcommands.
+     *
+     * <p>This mode is mutually exclusive with subcommand registration.</p>
+     *
+     * @param mainCommand the main command definition
+     * @return this builder instance for further configuration
+     * @throws Validate.ValidateExceptions if subcommands have already been registered
+     */
+    public CommandOptions setMainCommand(@Nonnull final CommandProperty mainCommand) {
+        mainCommandHandler.setMainCommand(mainCommand);
+        return this;
+    }
+
+}

Commands/src/main/java/org/broken/arrow/library/command/builers/CommandDisplayBuilder.java

@@ -0,0 +1,52 @@
+package org.broken.arrow.library.command.builers;
+
+import org.broken.arrow.library.command.commandhandler.MainCommandHandler;
+import org.broken.arrow.library.command.subcommand.CommandDisplayConfig;
+
+
+import javax.annotation.Nonnull;
+import java.util.function.Consumer;
+
+/**
+ * Final configuration stage for applying display-related settings
+ * to a command before returning to the main configuration flow.
+ *
+ * <p>This stage is typically entered after subcommand registration.</p>
+ */
+public class CommandDisplayBuilder {
+    private final CommandBuilder commandRegister;
+    private final MainCommandHandler mainCommandHandler;
+
+    /**
+     * Creates a new display builder.
+     *
+     * @param commandRegister parent command builder
+     * @param mainCommandHandler internal command handler
+     */
+    public CommandDisplayBuilder(@Nonnull final CommandBuilder commandRegister, @Nonnull final MainCommandHandler mainCommandHandler) {
+        this.commandRegister = commandRegister;
+        this.mainCommandHandler = mainCommandHandler;
+    }
+
+    /**
+     * Applies display configuration to the command.
+     *
+     * <p>This includes messages, prefixes, suffixes, and other visual output
+     * shown when interacting with the command system.</p>
+     *
+     * <pre>{@code
+     * display(config -> {
+     *     config.setPrefixMessage("...");
+     *     config.setSuffixMessage("...");
+     * });
+     * }</pre>
+     *
+     * @param callback consumer used to configure {@link CommandDisplayConfig}
+     * @return the original {@link CommandOptions} builder to continue configuration
+     */
+    public CommandOptions display(final Consumer<CommandDisplayConfig> callback) {
+        callback.accept(mainCommandHandler.getCommandDisplayConfig());
+        return commandRegister;
+    }
+
+}