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

class="kw">import com.hypixel.hytale.protocol.packets.interface_.CommandArgInfo;
class="kw">import com.hypixel.hytale.protocol.packets.interface_.CommandOptionalArgEntry;
class="kw">import com.hypixel.hytale.protocol.packets.interface_.CommandSuggestionOverride;
class="kw">import com.hypixel.hytale.protocol.packets.interface_.CommandTreeEntry;
class="kw">import com.hypixel.hytale.protocol.packets.interface_.CommandTreeSync;
class="kw">import com.hypixel.hytale.protocol.packets.interface_.CommandVariantEntry;
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.Argument;
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.RequiredArg;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractCommandCollection;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Collection;
class="kw">import java.util.Comparator;
class="kw">import java.util.List;
class="kw">import java.util.Map.Entry;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class CommandTreeBuilder {
   class="kw">private class="kw">static class="kw">final Comparator<AbstractCommand> BY_ARG_COUNT = Comparator.comparingInt(var0 -> var0.getRequiredArguments().size());

   CommandTreeBuilder() {
   }

   @Nonnull
   CommandTreeSync build(@Nonnull CommandSender var1, @Nonnull Collection<AbstractCommand> var2) {
      ArrayList var3 = new ArrayList<>();

      for (AbstractCommand var5 : var2) {
         if (var5.hasPermission(var1)) {
            var3.add(this.buildTreeEntry(var1, var5));
         }
      }

      CommandTreeSync var6 = new CommandTreeSync();
      var6.commands = var3.toArray(new CommandTreeEntry[0]);
      class="kw">return var6;
   }

   @Nonnull
   class="kw">private CommandTreeEntry buildTreeEntry(@Nonnull CommandSender var1, @Nonnull AbstractCommand var2) {
      class="kw">return this.buildTreeEntry(var1, var2, "/" + var2.getName());
   }

   class="kw">private CommandTreeEntry buildTreeEntry(@Nonnull CommandSender var1, @Nonnull AbstractCommand var2, @Nonnull String var3) {
      CommandTreeEntry var4 = new CommandTreeEntry();
      var4.name = var2.getName();
      var4.aliases = var2.getAliases().toArray(new String[0]);
      var4.description = var2.getDescription();
      var4.usageText = this.buildUsageText(var2, var3);
      var4.variants = this.buildVariantEntries(var2, var3);
      ArrayList var5 = new ArrayList<>();
      ArrayList var6 = new ArrayList<>();

      for (AbstractCommand var8 : var2.getSubCommands().values()) {
         if (var8.hasPermission(var1)) {
            var5.add(this.buildTreeEntry(var1, var8, var3 + " " + var8.getName()));
            var6.add(this.buildSubcommandHint(var8));
         }
      }

      var4.subcommands = var5.toArray(new CommandTreeEntry[0]);
      var4.subcommandHints = var6.toArray(new String[0]);
      var4.requiredArgs = buildArgInfoArray(var2.getRequiredArguments());
      var4.suggestionOverrides = buildSuggestionOverrides(var2);
      ArrayList var12 = new ArrayList<>();

      for (Entry var9 : var2.getOptionalArguments().entrySet()) {
         AbstractOptionalArg var10 = (AbstractOptionalArg<? class="kw">extends Argument<?, ?>, ?>)var9.getValue();
         if (var10.hasPermission(var1)) {
            CommandOptionalArgEntry var11 = new CommandOptionalArgEntry();
            var11.name = "--" + var9.getKey();
            var11.description = var10.getDescription();
            if (var10 class="kw">instanceof FlagArg) {
               var11.hint = "";
               var11.argTypeId = null;
            } else {
               var11.hint = "=<" + var10.getName() + ">";
               var11.argTypeId = var10.getArgumentType().getSuggestionTypeId();
            }

            var12.add(var11);
         }
      }

      var4.optionalArgs = var12.toArray(new CommandOptionalArgEntry[0]);
      class="kw">return var4;
   }

   @Nonnull
   class="kw">private CommandVariantEntry[] buildVariantEntries(@Nonnull AbstractCommand var1, @Nonnull String var2) {
      if (var1.getVariantCommands().isEmpty()) {
         class="kw">return new CommandVariantEntry[0];
      }

      ArrayList var3 = new ArrayList<>();
      var3.add(var1);
      var3.addAll(var1.getVariantCommands());
      var3.sort(BY_ARG_COUNT);
      ArrayList var4 = new ArrayList<>();

      for (AbstractCommand var6 : var3) {
         if (var6 != var1 || !(var6.getRequiredArguments().isEmpty() && var1 class="kw">instanceof AbstractCommandCollection var7) || var7.isNoArgVariant()) {
            CommandVariantEntry var8 = new CommandVariantEntry();
            if (var6.getRequiredArguments().isEmpty()) {
               var8.pattern = var1.getName();
            } else {
               var8.pattern = this.buildVariantArgPattern(var6);
            }

            var8.description = var6.getDescription();
            var8.requiredArgs = buildArgInfoArray(var6.getRequiredArguments());
            var8.suggestionOverrides = buildSuggestionOverrides(var6);
            var8.usageText = buildArgUsageText(var2, var6.getRequiredArguments());
            var4.add(var8);
         }
      }

      class="kw">return var4.toArray(new CommandVariantEntry[0]);
   }

   @Nonnull
   class="kw">private class="kw">static CommandArgInfo[] buildArgInfoArray(@Nonnull List<RequiredArg<?>> var0) {
      CommandArgInfo[] var1 = new CommandArgInfo[var0.size()];

      for (int var2 = 0; var2 < var0.size(); var2++) {
         RequiredArg var3 = var0.get(var2);
         CommandArgInfo var4 = new CommandArgInfo();
         var4.name = var3.getName();
         var4.description = var3.getDescription();
         var4.argTypeId = var3.getArgumentType().getSuggestionTypeId();
         var4.argTypeName = var3.getArgumentType().getName().getMessageId();
         var4.valueCount = var3.getArgumentType().getSuggestionValueCount();
         var1[var2] = var4;
      }

      class="kw">return var1;
   }

   @Nullable
   class="kw">private class="kw">static CommandSuggestionOverride[] buildSuggestionOverrides(@Nonnull AbstractCommand var0) {
      List var1 = var0.getSuggestionOverrides();
      if (var1 == null) {
         class="kw">return null;
      }

      CommandSuggestionOverride[] var2 = new CommandSuggestionOverride[var1.size()];

      for (int var3 = 0; var3 < var1.size(); var3++) {
         AbstractCommand.SuggestionOverrideEntry var4 = var1.get(var3);
         CommandSuggestionOverride var5 = new CommandSuggestionOverride();
         var5.argStart = var4.argStart();
         var5.argCount = var4.argCount();
         var5.argTypeId = var4.argTypeId();
         var2[var3] = var5;
      }

      class="kw">return var2;
   }

   @Nonnull
   class="kw">private String buildSubcommandHint(@Nonnull AbstractCommand var1) {
      if (!var1.getSubCommands().isEmpty() || !var1.getVariantCommands().isEmpty()) {
         class="kw">return " ...";
      } else {
         class="kw">return !var1.getRequiredArguments().isEmpty() ? this.buildVariantArgPattern(var1) : "";
      }
   }

   @Nonnull
   class="kw">private String buildVariantArgPattern(@Nonnull AbstractCommand var1) {
      List var2 = var1.getRequiredArguments();
      StringBuilder var3 = new StringBuilder();

      for (int var4 = 0; var4 < var2.size(); var4++) {
         if (var4 > 0) {
            var3.append(" ");
         }

         var3.append("<").append(var2.get(var4).getName()).append(">");
      }

      class="kw">return var3.toString();
   }

   @Nonnull
   class="kw">private String buildUsageText(@Nonnull AbstractCommand var1, @Nonnull String var2) {
      Collection var3 = var1.getVariantCommands();
      if (!var3.isEmpty()) {
         ArrayList var4 = new ArrayList<>();
         var4.add(var1);
         var4.addAll(var3);
         var4.sort(BY_ARG_COUNT);
         class="kw">return buildArgUsageText(var2, var4.getLast().getRequiredArguments());
      } else {
         class="kw">return buildArgUsageText(var2, var1.getRequiredArguments());
      }
   }

   @Nonnull
   class="kw">private class="kw">static String buildArgUsageText(@Nonnull String var0, @Nonnull List<RequiredArg<?>> var1) {
      StringBuilder var2 = new StringBuilder(var0);

      for (RequiredArg var4 : var1) {
         var2.append(" <").append(var4.getName()).append(">");
      }

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