class="kw">package com.hypixel.hytale.server.core.command.system;

class="kw">import com.hypixel.hytale.common.util.StringUtil;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.GameMode;
class="kw">import com.hypixel.hytale.server.core.Constants;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.AbstractOptionalArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.ArgWrapper;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.Argument;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.DefaultArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.FlagArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.OptionalArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.RequiredArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.WrappedArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.ArgumentType;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.ListArgumentType;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractCommandCollection;
class="kw">import com.hypixel.hytale.server.core.command.system.exceptions.GeneralCommandException;
class="kw">import com.hypixel.hytale.server.core.modules.i18n.I18nModule;
class="kw">import com.hypixel.hytale.server.core.permissions.PermissionQuery;
class="kw">import com.hypixel.hytale.server.core.permissions.PermissionsModule;
class="kw">import com.hypixel.hytale.server.core.plugin.PluginBase;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectBidirectionalIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectBooleanPair;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collection;
class="kw">import java.util.HashSet;
class="kw">import java.util.LinkedHashMap;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">abstract class AbstractCommand {
   @Nonnull
   class="kw">public class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">public class="kw">static class="kw">final String[] EMPTY_STRING_ARRAY = new String[0];
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_HELP_NO_PERMISSIBLE_SUB_COMMAND = Message.translation("server.commands.help.noPermissibleSubCommand");
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_PARSING_ERROR_NO_PERMISSION_FOR_COMMAND = Message.translation(
      "server.commands.parsing.error.noPermissionForCommand"
   );
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_PARSING_ERROR_ATTEMPTED_UNSAFE = Message.translation("server.commands.parsing.error.attemptedUnsafe");
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_PARSING_USAGE_REQUIRES_CONFIRMATION = Message.translation("server.commands.parsing.usage.requiresConfirmation");
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMAND_SINGLEPLAYER = Message.translation("server.commands.parsing.error.unavailableInSingleplayer");
   @Nonnull
   class="kw">static class="kw">final String CONFIRM_ARG_TAG = "confirm";
   @Nonnull
   class="kw">private class="kw">static class="kw">final String COLOR_STRING_ARG_REQUIRED = "#C1E0FF";
   @Nonnull
   class="kw">private class="kw">static class="kw">final String COLOR_STRING_ARG_OPTIONAL = "#7E9EBC";
   class="kw">private AbstractCommand parentCommand;
   @Nullable
   class="kw">private class="kw">final String name;
   @Nonnull
   class="kw">private class="kw">final Set<String> aliases = new HashSet<>();
   @Nullable
   class="kw">private class="kw">final String description;
   @Nonnull
   class="kw">private class="kw">final List<RequiredArg<?>> requiredArguments = new ObjectArrayList();
   @Nonnull
   class="kw">private class="kw">final Map<String, AbstractOptionalArg<?, ?>> optionalArguments = new Object2ObjectOpenHashMap();
   class="kw">private AbbreviationMap<AbstractOptionalArg<?, ?>> argumentAbbreviationMap;
   @Nonnull
   class="kw">private class="kw">final Map<String, AbstractCommand> subCommands = new LinkedHashMap<>();
   @Nonnull
   class="kw">private class="kw">final Map<String, String> subCommandsAliases = new LinkedHashMap<>();
   @Nonnull
   class="kw">private class="kw">final Int2ObjectMap<AbstractCommand> variantCommands = new Int2ObjectOpenHashMap();
   @Nullable
   class="kw">private CommandOwner owner;
   @Nullable
   class="kw">private PermissionQuery permission;
   class="kw">private boolean openToEveryone;
   @Nullable
   class="kw">private List<String> permissionGroups;
   class="kw">private int totalNumRequiredParameters;
   class="kw">private class="kw">final boolean requiresConfirmation;
   class="kw">private boolean unavailableInSingleplayer;
   class="kw">private boolean allowsExtraArguments;
   class="kw">private boolean hasBeenRegistered;
   class="kw">private boolean hasGreedyStringArg;

   class="kw">protected AbstractCommand(@Nullable String var1, @Nullable String var2, boolean var3) {
      this.name = var1 == null ? null : var1.toLowerCase(Locale.ROOT);
      this.description = var2;
      this.requiresConfirmation = var3;
      if (var3) {
         this.registerOptionalArg(new FlagArg(this, "confirm", ""));
      }
   }

   class="kw">protected AbstractCommand(@Nullable String var1, @Nullable String var2) {
      this(var1, var2, false);
   }

   class="kw">protected AbstractCommand(@Nullable String var1) {
      this(null, var1);
   }

   class="kw">public void setOwner(@Nonnull CommandOwner var1) {
      this.owner = var1;
      if (this.permission == null && !this.openToEveryone) {
         this.permission = PermissionQuery.of(this.generatePermission());
      }

      for (AbstractCommand var3 : this.subCommands.values()) {
         var3.setOwner(var1);
      }

      ObjectIterator var4 = this.variantCommands.values().iterator();

      while (var4.hasNext()) {
         AbstractCommand var5 = (AbstractCommand)var4.next();
         var5.setOwner(var1);
      }
   }

   @Nullable
   class="kw">protected String generatePermissionNode() {
      class="kw">return this.name == null ? null : this.name.toLowerCase(Locale.ROOT);
   }

   @Nonnull
   class="kw">private String generatePermission() {
      String var1 = this.generatePermissionNode();
      if (this.parentCommand != null) {
         String var4 = this.parentCommand.permission == null ? this.parentCommand.generatePermission() : this.parentCommand.permission.getId();
         String var5;
         if (var1 != null && !var1.isEmpty()) {
            var5 = var4 + "." + var1;
         } else {
            var5 = var4;
         }

         ((HytaleLogger.Api)LOGGER.atFine()).log("Generated missing permission '%s'.", var5);
         class="kw">return var5;
      } else if (this.owner class="kw">instanceof PluginBase var2) {
         class="kw">return var2.getBasePermission() + ".command." + var1;
      } else if (this.owner class="kw">instanceof CommandManager) {
         class="kw">return "hytale.system.command." + var1;
      } else {
         throw new IllegalArgumentException("Unknown owner type, please use PluginBase or CommandManager");
      }
   }

   @Nullable
   class="kw">public List<String> getPermissionGroups() {
      class="kw">return this.permissionGroups;
   }

   class="kw">protected void setPermissionGroups(@Nonnull String... var1) {
      this.permissionGroups = Arrays.asList(var1);
   }

   @Deprecated(forRemoval = true)
   class="kw">protected void setPermissionGroup(@Nonnull GameMode var1) {
      class="kw">switch (var1) {
         case Adventure:
            this.setPermissionGroups("hytale:Adventurer");
            break;
         case Creative:
            this.setPermissionGroups("hytale:WorldEditor");
      }
   }

   @Nonnull
   class="kw">public Map<String, Set<String>> getPermissionGroupsRecursive() {
      Map var1 = new Object2ObjectOpenHashMap();
      this.putRecursivePermissionGroups(var1);
      class="kw">return var1;
   }

   class="kw">public void putRecursivePermissionGroups(@Nonnull Map<String, Set<String>> var1) {
      List var2 = this.permissionGroups;
      if (var2 == null && this.parentCommand != null) {
         var2 = this.parentCommand.permissionGroups;
      }

      if (var2 != null && this.permission != null) {
         for (String var4 : var2) {
            if (var4 != null) {
               var1.computeIfAbsent(var4, var0 -> new HashSet<>()).add(this.permission.getId());
            }
         }
      }

      for (AbstractCommand var6 : this.subCommands.values()) {
         var6.putRecursivePermissionGroups(var1);
      }
   }

   class="kw">protected void setUnavailableInSingleplayer(boolean var1) {
      this.unavailableInSingleplayer = var1;
   }

   class="kw">public void setAllowsExtraArguments(boolean var1) {
      this.allowsExtraArguments = var1;
   }

   @Nonnull
   class="kw">public MatchResult matches(@Nonnull String var1, @Nonnull String var2, int var3) {
      class="kw">return this.matches(var1, var2, var3, 0);
   }

   @Nonnull
   class="kw">private MatchResult matches(@Nonnull String var1, @Nonnull String var2, int var3, int var4) {
      if (this.name != null && this.name.contains(var2)) {
         class="kw">return MatchResult.of(var3, var4, 0, this.name, var2);
      }

      for (String var6 : this.aliases) {
         if (var6.contains(var2)) {
            class="kw">return MatchResult.of(var3, var4, 1, var6, var2);
         }
      }

      for (AbstractOptionalArg var15 : this.optionalArguments.values()) {
         if (var15.getName().contains(var2)) {
            class="kw">return MatchResult.of(var3, var4, 3, var15.getName(), var2);
         }

         for (String var8 : var15.getAliases()) {
            if (var8.contains(var2)) {
               class="kw">return MatchResult.of(var3, var4, 3, var8, var2);
            }
         }
      }

      for (RequiredArg var16 : this.requiredArguments) {
         if (var16.getName().contains(var2)) {
            class="kw">return MatchResult.of(var3, var4, 3, var16.getName(), var2);
         }
      }

      if (this.description != null) {
         String var11 = I18nModule.get().getMessage(var1, this.description);
         if (var11 != null && var11.contains(var2)) {
            class="kw">return MatchResult.of(var3, var4, 4, var11, var2);
         }
      }

      for (AbstractOptionalArg var17 : this.optionalArguments.values()) {
         String var20 = var17.getDescription();
         if (var20 != null) {
            String var23 = I18nModule.get().getMessage(var1, var20);
            if (var23 != null && var23.contains(var2)) {
               class="kw">return MatchResult.of(var3, var4, 5, var23, var2);
            }
         }
      }

      for (AbstractCommand var18 : this.subCommands.values()) {
         MatchResult var21 = var18.matches(var1, var2, var3, var4 + 1);
         if (!var21.equals(MatchResult.NONE)) {
            class="kw">return var21;
         }
      }

      ObjectIterator var14 = this.variantCommands.values().iterator();

      while (var14.hasNext()) {
         AbstractCommand var19 = (AbstractCommand)var14.next();
         MatchResult var22 = var19.matches(var1, var2, var3, var4 + 1);
         if (!var22.equals(MatchResult.NONE)) {
            class="kw">return var22;
         }
      }

      class="kw">return MatchResult.NONE;
   }

   class="kw">public void completeRegistration() class="kw">throws GeneralCommandException {
      this.hasBeenRegistered = true;
      if (this.permission != null) {
         PermissionsModule.registerPermission(this.permission.getId());
      }

      for (AbstractCommand var2 : this.subCommands.values()) {
         var2.completeRegistration();
      }

      ObjectIterator var3 = this.variantCommands.values().iterator();

      while (var3.hasNext()) {
         AbstractCommand var4 = (AbstractCommand)var3.next();
         var4.completeRegistration();
      }

      this.validateVariantNumberOfRequiredParameters(new ParseResult(true));
      this.validateDefaultArguments(new ParseResult(true));
      this.createOptionalArgumentAbbreviationMap();
   }

   @Nullable
   class="kw">protected PermissionQuery registerExtendedPermission(@Nonnull String var1) {
      if (this.permission == null) {
         class="kw">return null;
      }

      String var2 = this.permission.getId() + "." + var1;
      PermissionsModule.registerPermission(var2);
      class="kw">return PermissionQuery.of(var2);
   }

   class="kw">private void createOptionalArgumentAbbreviationMap() {
      AbbreviationMap.AbbreviationMapBuilder var1 = AbbreviationMap.create();

      for (AbstractOptionalArg var3 : this.optionalArguments.values()) {
         var1.put(var3.getName(), var3);

         for (String var5 : var3.getAliases()) {
            var1.put(var5, var3);
         }
      }

      this.argumentAbbreviationMap = var1.build();
   }

   class="kw">private void validateVariantNumberOfRequiredParameters(@Nonnull ParseResult var1) {
      ObjectIterator var2 = this.variantCommands.int2ObjectEntrySet().iterator();

      while (var2.hasNext()) {
         Entry var3 = (Entry<AbstractCommand>)var2.next();
         if (this.totalNumRequiredParameters == ((AbstractCommand)var3.getValue()).totalNumRequiredParameters) {
            var1.fail(
               Message.raw(
                  "Command '"
                     + this.getFullyQualifiedName()
                     + "' and its variant '"
                     + ((AbstractCommand)var3.getValue()).toString()
                     + "' both have "
                     + this.totalNumRequiredParameters
                     + " required parameters. Variants must have different numbers of required parameters."
               )
            );
            class="kw">return;
         }
      }
   }

   class="kw">private void validateDefaultArguments(@Nonnull ParseResult var1) {
      for (AbstractOptionalArg var3 : this.optionalArguments.values()) {
         if (var3 class="kw">instanceof DefaultArg var4) {
            var4.validateDefaultValue(var1);
         }
      }
   }

   class="kw">public void requirePermission(@Nonnull String var1) {
      this.checkNotRegistered();
      this.permission = PermissionQuery.of(var1);
      this.openToEveryone = false;
   }

   class="kw">public void requirePermission(@Nonnull PermissionQuery var1) {
      this.checkNotRegistered();
      this.permission = var1;
      this.openToEveryone = false;
   }

   class="kw">public void requireNoPermission() {
      this.checkNotRegistered();
      this.permission = null;
      this.openToEveryone = true;
   }

   class="kw">private void checkNotRegistered() {
      if (this.hasBeenRegistered) {
         throw new IllegalStateException("Cannot change permissions when a command has already completed registration");
      }
   }

   @Nullable
   class="kw">public String getFullyQualifiedName() {
      if (this.parentCommand != null) {
         class="kw">return this.isVariant() ? this.parentCommand.getFullyQualifiedName() : this.parentCommand.getFullyQualifiedName() + " " + this.name;
      } else {
         class="kw">return this.name;
      }
   }

   class="kw">public int countParents() {
      class="kw">return this.parentCommand == null ? 0 : this.parentCommand.countParents() + 1;
   }

   class="kw">public void addAliases(@Nonnull String... var1) {
      if (this.hasBeenRegistered) {
         throw new IllegalStateException("Cannot add aliases when a command has already completed registration");
      }

      if (this.name == null) {
         throw new IllegalStateException("Cannot add aliases to a command with no name");
      }

      for (String var5 : var1) {
         this.aliases.add(var5.toLowerCase(Locale.ROOT));
      }
   }

   class="kw">public void addSubCommand(@Nonnull AbstractCommand var1) {
      if (this.hasBeenRegistered) {
         throw new IllegalStateException("Cannot add new subcommands when a command has already completed registration");
      }

      if (this.isVariant()) {
         throw new IllegalStateException("Cannot add a subcommand to a variant command, can only add subcommands to named commands");
      }

      if (var1.name == null) {
         throw new IllegalArgumentException("Cannot add a subcommand with no name");
      }

      if (var1.parentCommand != null) {
         throw new IllegalArgumentException("Cannot re-use subcommands. Only one parent command allowed for each subcommand");
      }

      var1.parentCommand = this;
      if (this.subCommands.containsKey(var1.name)) {
         throw new IllegalArgumentException("Cannot have multiple subcommands with the same name");
      }

      if (this.subCommandsAliases.containsKey(var1.name)) {
         throw new IllegalArgumentException("Command has same name as existing command alias for command: " + var1.name);
      }

      this.subCommands.put(var1.name, var1);

      for (String var3 : var1.aliases) {
         if (this.subCommandsAliases.containsKey(var3) || this.subCommands.containsKey(var3)) {
            throw new IllegalArgumentException("Cannot specify a subcommand alias with the same name as an existing command or alias: " + var3);
         }

         this.subCommandsAliases.put(var3, var1.name);
      }

      var1.hasBeenRegistered = true;
   }

   class="kw">public void addUsageVariant(@Nonnull AbstractCommand var1) {
      if (this.hasBeenRegistered) {
         throw new IllegalStateException("Cannot add new variants when a command has already completed registration");
      }

      if (this.isVariant()) {
         throw new IllegalStateException("Cannot add a command variant to a variant command, can only add variants to named commands");
      }

      if (var1.name != null) {
         throw new IllegalArgumentException("Cannot add a variant command with a name, use the description-only constructor");
      }

      if (var1.parentCommand != null) {
         throw new IllegalArgumentException("Cannot re-use variant commands. Only one parent command allowed for each variant command");
      }

      AbstractCommand var2 = (AbstractCommand)this.variantCommands.put(var1.totalNumRequiredParameters, var1);
      if (var2 != null) {
         throw new IllegalArgumentException(
            "You have already registered a variant command with "
               + var1.totalNumRequiredParameters
               + " required parameters. Command's class name: "
               + var2.getClass().getName()
         );
      }

      var1.parentCommand = this;
      var1.hasBeenRegistered = true;
   }

   @Nullable
   class="kw">public CompletableFuture<Void> acceptCall(@Nonnull CommandSender var1, @Nonnull ParserContext var2, @Nonnull ParseResult var3) {
      var2.convertToSubCommand();
      class="kw">return this.acceptCall0(var1, var2, var3);
   }

   @Nullable
   class="kw">private CompletableFuture<Void> acceptCall0(@Nonnull CommandSender var1, @Nonnull ParserContext var2, @Nonnull ParseResult var3) {
      int var4 = var2.getNumPreOptionalTokens();
      ObjectBooleanPair var5 = this.checkForExecutingSubcommands(var1, var2, var3, var4);
      if (var3.failed()) {
         class="kw">return null;
      }

      if (var5.rightBoolean()) {
         class="kw">return (CompletableFuture<Void>)var5.left();
      }

      if (!this.hasPermission(var1)) {
         var3.fail(MESSAGE_COMMANDS_PARSING_ERROR_NO_PERMISSION_FOR_COMMAND);
         class="kw">return null;
      }

      if (this class="kw">instanceof AbstractCommandCollection && var4 != 0) {
         HashSet var10 = new HashSet<>(this.subCommands.keySet());
         var10.addAll(this.subCommandsAliases.keySet());
         String var7 = var2.getFirstToken();
         String var8 = "\n/" + this.getFullyQualifiedName() + " ";
         String var9 = var8 + String.join(var8, StringUtil.sortByFuzzyDistance(var7, var10, 5));
         var3.fail(
            Message.translation("server.commands.parsing.error.commandCollectionSubcommandNotFound").param("subcommand", var7).param("suggestions", var9)
         );
         class="kw">return null;
      }

      if (var2.isHelpSpecified()) {
         var1.sendMessage(this.getUsageString(var1));
         class="kw">return null;
      }

      if (this.unavailableInSingleplayer && Constants.SINGLEPLAYER) {
         var3.fail(MESSAGE_COMMAND_SINGLEPLAYER);
         class="kw">return null;
      }

      if (this.requiresConfirmation && !var2.isConfirmationSpecified()) {
         var3.fail(MESSAGE_COMMANDS_PARSING_ERROR_ATTEMPTED_UNSAFE);
         class="kw">return null;
      }

      if (this.allowsExtraArguments) {
         if (var4 < this.totalNumRequiredParameters) {
            var3.fail(
               Message.translation("server.commands.parsing.error.wrongNumberRequiredParameters")
                  .param("expected", this.totalNumRequiredParameters)
                  .param("actual", var4)
                  .insert("\n")
                  .insert(Message.translation("server.commands.help.usagecolon").param("usage", this.getUsageShort(var1, true)))
                  .insert("\n")
                  .insert(Message.translation("server.commands.help.useHelpToLearnMore").param("command", this.getFullyQualifiedName()))
            );
            class="kw">return null;
         }
      } else if (this.totalNumRequiredParameters != var4) {
         var3.fail(
            Message.translation("server.commands.parsing.error.wrongNumberRequiredParameters")
               .param("expected", this.totalNumRequiredParameters)
               .param("actual", var4)
               .insert("\n")
               .insert(Message.translation("server.commands.help.usagecolon").param("usage", this.getUsageShort(var1, true)))
               .insert("\n")
               .insert(Message.translation("server.commands.help.useHelpToLearnMore").param("command", this.getFullyQualifiedName()))
         );
         class="kw">return null;
      }

      CommandContext var6 = new CommandContext(this, var1, var2.getInputString());
      this.processRequiredArguments(var2, var3, var6);
      if (var3.failed()) {
         class="kw">return null;
      }

      this.processOptionalArguments(var2, var3, var6);
      class="kw">return var3.failed() ? null : this.execute(var6);
   }

   class="kw">public boolean hasPermission(@Nonnull CommandSender var1) {
      PermissionQuery var2 = this.permission;
      if (var2 == null) {
         class="kw">return true;
      }

      if (var1.hasPermission(var2)) {
         if (this.parentCommand == null) {
            class="kw">return true;
         } else {
            class="kw">return this.permissionGroups != null ? true : this.parentCommand.hasPermission(var1);
         }
      } else {
         class="kw">return false;
      }
   }

   @Nonnull
   class="kw">private ObjectBooleanPair<CompletableFuture<Void>> checkForExecutingSubcommands(
      @Nonnull CommandSender var1, @Nonnull ParserContext var2, @Nonnull ParseResult var3, int var4
   ) {
      if (var2.getNumPreOptSingleValueTokensBeforeListTokens() >= 0) {
         if (!this.subCommands.isEmpty()) {
            String var5 = var2.getPreOptionalSingleValueToken(0);
            AbstractCommand var6 = var5 == null ? null : this.getSubCommand(var5);
            if (var6 != null) {
               var2.convertToSubCommand();
               class="kw">return ObjectBooleanPair.of(var6.acceptCall0(var1, var2, var3), true);
            }
         }

         AbstractCommand var7 = (AbstractCommand)this.variantCommands.get(var4);
         if (this.totalNumRequiredParameters != var4 && var7 != null) {
            class="kw">return ObjectBooleanPair.of(var7.acceptCall0(var1, var2, var3), true);
         }
      }

      class="kw">return ObjectBooleanPair.of(null, false);
   }

   class="kw">private void processRequiredArguments(@Nonnull ParserContext var1, @Nonnull ParseResult var2, @Nonnull CommandContext var3) {
      int var4 = 0;

      for (RequiredArg var6 : this.requiredArguments) {
         if (var6.getArgumentType().isGreedyString()) {
            String var10 = this.extractGreedyRawTail(var1);
            var3.appendArgumentData(var6, new String[]{var10}, false, var2);
            class="kw">return;
         }

         if (var6.getArgumentType().isListArgument() && var1.isListToken(var4)) {
            ParserContext.PreOptionalListContext var9 = var1.getPreOptionalListToken(var4);
            var4++;
            var3.appendArgumentData(var6, var9.getTokens(), true, var2);
         } else {
            String[] var7 = new String[var6.getArgumentType().getNumberOfParameters()];

            for (int var8 = 0; var8 < var6.getArgumentType().getNumberOfParameters(); var8++) {
               if (var1.isListToken(var4)) {
                  var2.fail(Message.translation("server.commands.parsing.error.notAList").param("name", var6.getName()));
                  class="kw">return;
               }

               var7[var8] = var1.getPreOptionalSingleValueToken(var4);
               var4++;
            }

            var3.appendArgumentData(var6, var7, false, var2);
            if (var2.failed()) {
               class="kw">return;
            }
         }
      }
   }

   @Nonnull
   class="kw">private String extractGreedyRawTail(@Nonnull ParserContext var1) {
      String var2 = var1.getRawInput();
      int var3 = var1.getSubCommandIndex();

      for (RequiredArg var5 : this.requiredArguments) {
         if (var5.getArgumentType().isGreedyString()) {
            break;
         }

         var3 += var5.getArgumentType().getNumberOfParameters();
      }

      int var6 = 0;

      for (int var7 = 0; var7 < var3 && var6 < var2.length(); var7++) {
         while (var6 < var2.length() && var2.charAt(var6) == ' ') {
            var6++;
         }

         while (var6 < var2.length() && var2.charAt(var6) != ' ') {
            var6++;
         }
      }

      while (var6 < var2.length() && var2.charAt(var6) == ' ') {
         var6++;
      }

      class="kw">return var2.substring(var6);
   }

   class="kw">private void processOptionalArguments(@Nonnull ParserContext var1, @Nonnull ParseResult var2, @Nonnull CommandContext var3) {
      ObjectBidirectionalIterator var4 = var1.getOptionalArgs().iterator();

      while (var4.hasNext()) {
         java.util.Map.Entry var5 = (java.util.Map.Entry<String, List<List<String>>>)var4.next();
         AbstractOptionalArg var6 = (AbstractOptionalArg<? class="kw">extends Argument<?, ?>, ?>)this.getOptionalArgument(var5.getKey());
         if (var6 == null) {
            var2.fail(Message.translation("server.commands.parsing.error.couldNotFindOptionalArgName").param("input", var5.getKey()));
            class="kw">return;
         }

         if (!var6.hasPermission(var3.sender())) {
            var2.fail(Message.translation("server.commands.parsing.error.noPermissionForOptional").param("argument", var5.getKey()));
            class="kw">return;
         }

         List var7 = var5.getValue();
         if (var6.getArgumentType().isListArgument() && var7.size() > 1) {
            String[] var8 = new String[var7.size() * var7.getFirst().size()];

            for (int var9 = 0; var9 < var7.size(); var9++) {
               List var10 = var7.get(var9);

               for (int var11 = 0; var11 < var10.size(); var11++) {
                  var8[var9 * var10.size() + var11] = var10.get(var11);
               }
            }

            var3.appendArgumentData(var6, var8, true, var2);
         } else {
            var3.appendArgumentData(var6, var7.isEmpty() ? EMPTY_STRING_ARRAY : var7.getFirst().toArray(EMPTY_STRING_ARRAY), false, var2);
         }
      }

      for (AbstractOptionalArg var13 : this.optionalArguments.values()) {
         var13.verifyArgumentDependencies(var3, var2);
      }
   }

   @Nullable
   class="kw">protected class="kw">abstract CompletableFuture<Void> execute(@Nonnull CommandContext var1);

   @Nonnull
   class="kw">public Message getUsageString(@Nonnull CommandSender var1) {
      Message var2 = Message.raw("");

      for (RequiredArg var4 : this.requiredArguments) {
         var2.insert(" ").insert(var4.getUsageMessageWithoutDescription());
         if (var4.getArgumentType().isListArgument()) {
            var2.insert("/...");
         }
      }

      Message var20 = this.requiresConfirmation ? MESSAGE_COMMANDS_PARSING_USAGE_REQUIRES_CONFIRMATION : Message.raw("");
      Message var21 = Message.raw("");
      boolean var5 = false;

      for (RequiredArg var7 : this.requiredArguments) {
         var5 = true;
         var21.insert("\n    ").insert(var7.getUsageMessage());
      }

      Message var22 = Message.raw("");
      boolean var23 = false;
      Message var8 = Message.raw("");
      boolean var9 = false;
      Message var10 = Message.raw("");
      boolean var11 = false;

      for (java.util.Map.Entry var13 : this.optionalArguments.entrySet()) {
         AbstractOptionalArg var14 = (AbstractOptionalArg<? class="kw">extends Argument<?, ?>, ?>)var13.getValue();
         if (var14.hasPermission(var1)) {
            class="kw">switch (var14) {
               case OptionalArg var17:
                  var23 = true;
                  var22.insert("\n    ").insert(var14.getUsageMessage());
                  break;
               case DefaultArg var18:
                  var9 = true;
                  var8.insert("\n    ").insert(var14.getUsageMessage());
                  break;
               case FlagArg var19:
                  var11 = true;
                  var10.insert("\n    ").insert(var14.getUsageMessage());
                  break;
               class="kw">default:
            }
         }
      }

      if (var5) {
         var21 = Message.translation("server.commands.parsing.usage.requiredArgs").param("args", var21);
      }

      if (var23) {
         var22 = Message.translation("server.commands.parsing.usage.optionalArgs").param("args", var22);
      }

      if (var11) {
         var10 = Message.translation("server.commands.parsing.usage.flagArgs").param("args", var10);
      }

      if (var9) {
         var8 = Message.translation("server.commands.parsing.usage.defaultArgs").param("args", var8);
      }

      Message var24 = Message.raw("");
      ObjectIterator var25 = this.variantCommands.values().iterator();

      while (var25.hasNext()) {
         AbstractCommand var27 = (AbstractCommand)var25.next();
         if (var27.hasPermission(var1)) {
            var24.insert(
               Message.translation("server.commands.parsing.usage.subcommands")
                  .param("separator", Message.translation("server.commands.parsing.usage.subcommandSeparator"))
                  .param("usage", var27.getUsageString(var1))
            );
         }
      }

      Message var26 = Message.raw("");

      for (AbstractCommand var30 : this.subCommands.values()) {
         if (var30.hasPermission(var1)) {
            var26.insert(
               Message.translation("server.commands.parsing.usage.subcommands")
                  .param("separator", Message.translation("server.commands.parsing.usage.subcommandSeparator"))
                  .param("usage", var30.getUsageString(var1))
            );
         }
      }

      Message var29 = Message.raw("\nArgument Types:");
      HashSet var31 = new HashSet<>();

      for (RequiredArg var35 : this.requiredArguments) {
         var31.add(var35.getArgumentType());
      }

      for (AbstractOptionalArg var36 : this.optionalArguments.values()) {
         var31.add(var36.getArgumentType());
      }

      for (ArgumentType var37 : var31) {
         var29.insert("\n    ")
            .insert(var37.getName())
            .insert(": ")
            .insert(var37.getArgumentUsage())
            .insert("\n        Examples: ")
            .insert("'")
            .insert(String.join("', '", var37.getExamples()))
            .insert("'.");
      }

      class="kw">return Message.translation("server.commands.parsing.usage.header")
         .param("fullyQualifiedName", this.getFullyQualifiedName())
         .param("description", this.description != null ? Message.translation(this.description) : Message.empty())
         .param("listOfRequiredArgs", var2)
         .param("requiresConfirmation", var20)
         .param("requiredArgs", var21)
         .param("optionalArgs", var22)
         .param("defaultArgs", var8)
         .param("flagArgs", var10)
         .param("argTypes", var29)
         .param("variants", var24)
         .param("subcommands", var26);
   }

   @Nonnull
   class="kw">public Message getUsageShort(@Nonnull CommandSender var1, boolean var2) {
      String var3 = " ".repeat(this.countParents());
      if (this.subCommands.isEmpty() && this.variantCommands.isEmpty()) {
         String var9 = this.getFullyQualifiedName();
         Message var10 = Message.raw(var3).insert(var2 ? (var9 != null ? var9 : "???") : (this.name != null ? this.name : ""));

         for (RequiredArg var14 : this.requiredArguments) {
            var10.insert(" ").insert(var14.getUsageOneLiner().color("#C1E0FF"));
         }

         for (AbstractOptionalArg var15 : this.optionalArguments.values()) {
            if (var15.hasPermission(var1)) {
               var10.insert(" ").insert(var15.getUsageOneLiner().color("#7E9EBC"));
            }
         }

         class="kw">return var10;
      } else {
         String var4 = this.parentCommand == null ? "/" : var3;
         Message var5 = Message.raw(var4).insert(this.name);
         boolean var6 = false;
         ObjectIterator var7 = this.variantCommands.values().iterator();

         while (var7.hasNext()) {
            AbstractCommand var8 = (AbstractCommand)var7.next();
            if (var8.hasPermission(var1)) {
               var5.insert("\n ").insert(var3).insert(var8.getUsageShort(var1, var2));
               var6 = true;
            }
         }

         for (AbstractCommand var16 : this.subCommands.values()) {
            if (var16.hasPermission(var1)) {
               var5.insert("\n ").insert(var3).insert(var16.getUsageShort(var1, var2));
               var6 = true;
            }
         }

         if (!var6) {
            var5.insert("\n ").insert(MESSAGE_COMMANDS_HELP_NO_PERMISSIBLE_SUB_COMMAND);
         }

         class="kw">return var5;
      }
   }

   @Nonnull
   class="kw">private <R class="kw">extends RequiredArg<D>, D> R registerRequiredArg(@Nonnull R var1) {
      if (this.hasBeenRegistered) {
         throw new IllegalStateException("Cannot add new arguments when a command has already completed registration");
      }

      if (!var1.getCommandRegisteredTo().equals(this) || this.requiredArguments.contains(var1)) {
         throw new IllegalArgumentException("Cannot re-use arguments");
      }

      if (this.hasGreedyStringArg) {
         throw new IllegalStateException("Cannot register additional required arguments after a greedy string argument");
      }

      if (var1.getArgumentType().isGreedyString()) {
         this.hasGreedyStringArg = true;
         this.allowsExtraArguments = true;
      }

      this.totalNumRequiredParameters = this.totalNumRequiredParameters + var1.getArgumentType().getNumberOfParameters();
      this.requiredArguments.add(var1);
      class="kw">return var1;
   }

   @Nonnull
   class="kw">private <R class="kw">extends AbstractOptionalArg<?, D>, D> R registerOptionalArg(@Nonnull R var1) {
      if (this.hasBeenRegistered) {
         throw new IllegalStateException("Cannot add new arguments when a command has already completed registration");
      } else if (var1.getCommandRegisteredTo().equals(this) && !this.optionalArguments.containsKey(var1.getName().toLowerCase(Locale.ROOT))) {
         this.optionalArguments.put(var1.getName().toLowerCase(Locale.ROOT), var1);
         class="kw">return var1;
      } else {
         throw new IllegalArgumentException("Cannot re-use arguments");
      }
   }

   @Nonnull
   class="kw">public <D> RequiredArg<D> withRequiredArg(@Nonnull String var1, @Nonnull String var2, @Nonnull ArgumentType<D> var3) {
      class="kw">return this.registerRequiredArg(new RequiredArg<>(this, var1, var2, var3));
   }

   class="kw">public <W class="kw">extends WrappedArg<D>, D> W withRequiredArg(@Nonnull String var1, @Nonnull String var2, @Nonnull ArgWrapper<W, D> var3) {
      class="kw">return var3.wrapArg(this.registerRequiredArg(new RequiredArg<>(this, var1, var2, var3.argumentType())));
   }

   @Nonnull
   class="kw">public <D> RequiredArg<List<D>> withListRequiredArg(@Nonnull String var1, @Nonnull String var2, @Nonnull ArgumentType<D> var3) {
      class="kw">return this.registerRequiredArg(new RequiredArg<>(this, var1, var2, new ListArgumentType<>(var3)));
   }

   @Nonnull
   class="kw">public <D> DefaultArg<D> withDefaultArg(String var1, String var2, ArgumentType<D> var3, @Nullable D var4, String var5) {
      class="kw">return this.registerOptionalArg(new DefaultArg<>(this, var1, var2, var3, var4, var5));
   }

   class="kw">public <W class="kw">extends WrappedArg<D>, D> W withDefaultArg(
      @Nonnull String var1, @Nonnull String var2, @Nonnull ArgWrapper<W, D> var3, D var4, @Nonnull String var5
   ) {
      class="kw">return var3.wrapArg(this.registerOptionalArg(new DefaultArg<>(this, var1, var2, var3.argumentType(), var4, var5)));
   }

   @Nonnull
   class="kw">public <D> DefaultArg<List<D>> withListDefaultArg(
      @Nonnull String var1, @Nonnull String var2, @Nonnull ArgumentType<D> var3, List<D> var4, @Nonnull String var5
   ) {
      class="kw">return this.registerOptionalArg(new DefaultArg<>(this, var1, var2, new ListArgumentType<>(var3), var4, var5));
   }

   @Nonnull
   class="kw">public <D> OptionalArg<D> withOptionalArg(@Nonnull String var1, @Nonnull String var2, @Nonnull ArgumentType<D> var3) {
      class="kw">return this.registerOptionalArg(new OptionalArg<>(this, var1, var2, var3));
   }

   class="kw">public <W class="kw">extends WrappedArg<D>, D> W withOptionalArg(@Nonnull String var1, @Nonnull String var2, @Nonnull ArgWrapper<W, D> var3) {
      class="kw">return var3.wrapArg(this.registerOptionalArg(new OptionalArg<>(this, var1, var2, var3.argumentType())));
   }

   @Nonnull
   class="kw">public <D> OptionalArg<List<D>> withListOptionalArg(@Nonnull String var1, @Nonnull String var2, @Nonnull ArgumentType<D> var3) {
      class="kw">return this.registerOptionalArg(new OptionalArg<>(this, var1, var2, new ListArgumentType<>(var3)));
   }

   @Nonnull
   class="kw">public FlagArg withFlagArg(@Nonnull String var1, @Nonnull String var2) {
      class="kw">return this.registerOptionalArg(new FlagArg(this, var1, var2));
   }

   class="kw">public boolean isVariant() {
      class="kw">return this.name == null;
   }

   @Nullable
   class="kw">public String getName() {
      class="kw">return this.name;
   }

   @Nonnull
   class="kw">public Set<String> getAliases() {
      class="kw">return this.aliases;
   }

   @Nullable
   class="kw">public String getDescription() {
      class="kw">return this.description;
   }

   @Nullable
   class="kw">public CommandOwner getOwner() {
      class="kw">return this.owner;
   }

   @Nullable
   class="kw">public String getPermission() {
      class="kw">return this.permission == null ? null : this.permission.getId();
   }

   @Nonnull
   class="kw">public Map<String, AbstractCommand> getSubCommands() {
      class="kw">return this.subCommands;
   }

   @Nullable
   class="kw">public AbstractCommand getSubCommand(@Nonnull String var1) {
      String var2 = var1.toLowerCase(Locale.ROOT);
      AbstractCommand var3 = this.subCommands.get(var2);
      if (var3 != null) {
         class="kw">return var3;
      }

      String var4 = this.subCommandsAliases.get(var2);
      class="kw">return var4 != null ? this.subCommands.get(var4) : null;
   }

   @Nonnull
   class="kw">public List<RequiredArg<?>> getRequiredArguments() {
      class="kw">return this.requiredArguments;
   }

   @Nonnull
   class="kw">public Map<String, AbstractOptionalArg<?, ?>> getOptionalArguments() {
      class="kw">return this.optionalArguments;
   }

   @Nullable
   class="kw">public AbstractOptionalArg<?, ?> getOptionalArgument(@Nonnull String var1) {
      class="kw">return this.argumentAbbreviationMap == null ? null : this.argumentAbbreviationMap.get(var1.toLowerCase(Locale.ROOT));
   }

   @Nonnull
   class="kw">public Collection<AbstractCommand> getVariantCommands() {
      class="kw">return this.variantCommands.values();
   }

   @Nullable
   class="kw">public AbstractCommand getVariantByArgCount(int var1) {
      class="kw">return (AbstractCommand)this.variantCommands.get(var1);
   }

   @Nullable
   class="kw">public List<AbstractCommand.SuggestionOverrideEntry> getSuggestionOverrides() {
      List var1 = null;

      for (int var2 = 0; var2 < this.requiredArguments.size(); var2++) {
         ArgumentType var3 = this.requiredArguments.get(var2).getSuggestionOverrideType();
         if (var3 != null) {
            if (var1 == null) {
               var1 = new ArrayList<>();
            }

            var1.add(new AbstractCommand.SuggestionOverrideEntry(var2, var3.getNumberOfParameters(), var3));
         }
      }

      class="kw">return var1;
   }

   class="kw">public boolean hasBeenRegistered() {
      class="kw">return this.hasBeenRegistered;
   }

   class="kw">public record SuggestionOverrideEntry(int argStart, int argCount, @Nonnull ArgumentType<?> overrideType) {
      class="kw">public SuggestionOverrideEntry {
      }

      @Nonnull
      class="kw">public String argTypeId() {
         class="kw">return this.overrideType.getSuggestionTypeId();
      }
   }
}