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

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.RequiredArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.ArgumentType;
class="kw">import com.hypixel.hytale.server.core.command.system.suggestion.SuggestionResult;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Collection;
class="kw">import java.util.LinkedHashSet;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">final class CommandCompletion {
   class="kw">private CommandCompletion() {
   }

   @Nonnull
   class="kw">public class="kw">static List<String> suggest(
      @Nonnull CommandSender var0,
      @Nonnull Collection<AbstractCommand> var1,
      @Nonnull Function<String, AbstractCommand> var2,
      @Nonnull List<String> var3,
      int var4
   ) {
      if (var4 >= 0 && var4 < var3.size()) {
         String var5 = var3.get(var4);
         if (var4 == 0) {
            class="kw">return suggestCommandNames(var0, var1, var5);
         }

         AbstractCommand var6 = var2.apply(stripSlash(var3.get(0)).toLowerCase(Locale.ROOT));
         if (var6 != null && var6.hasPermission(var0)) {
            int var7 = 1;

            for (int var8 = 1; var8 < var4; var8++) {
               AbstractCommand var9 = var6.getSubCommand(var3.get(var8));
               if (var9 == null || !var9.hasPermission(var0)) {
                  break;
               }

               var6 = var9;
               var7 = var8 + 1;
            }

            Set var13 = new LinkedHashSet<>();
            if (ParserContext.isOptionalArgumentToken(var5)) {
               int var15 = var5.indexOf(61);
               if (var15 >= 0) {
                  suggestInlineOptionalValue(var0, var6, var5, var15, var13);
               } else {
                  suggestOptionalArgNames(var0, var6, var5, var13);
               }

               class="kw">return new ArrayList<>(var13);
            } else {
               int var14 = var4 - var7;
               if (var14 == 0) {
                  for (Entry var11 : var6.getSubCommands().entrySet()) {
                     if (var11.getValue().hasPermission(var0) && startsWithIgnoreCase(var11.getKey(), var5)) {
                        var13.add(var11.getKey());
                     }
                  }
               }

               int var16 = lastOptionalTokenIndex(var3, var7, var4);
               if (var16 >= 0) {
                  suggestOptionalArgValues(var0, var6, var3, var16, var4, var13);
               } else {
                  suggestArgValues(var0, var6, var3, var7, var4, var13);

                  for (AbstractCommand var12 : var6.getVariantCommands()) {
                     if (var12.hasPermission(var0)) {
                        suggestArgValues(var0, var12, var3, var7, var4, var13);
                     }
                  }
               }

               class="kw">return new ArrayList<>(var13);
            }
         } else {
            class="kw">return List.of();
         }
      } else {
         class="kw">return List.of();
      }
   }

   @Nonnull
   class="kw">private class="kw">static List<String> suggestCommandNames(@Nonnull CommandSender var0, @Nonnull Collection<AbstractCommand> var1, @Nonnull String var2) {
      boolean var3 = var2.startsWith("/");
      String var4 = var3 ? var2.substring(1) : var2;
      List var5 = new ArrayList<>();

      for (AbstractCommand var7 : var1) {
         String var8 = var7.getName();
         if (var8 != null && var7.hasPermission(var0) && startsWithIgnoreCase(var8, var4)) {
            var5.add(var3 ? "/" + var8 : var8);
         }
      }

      class="kw">return var5;
   }

   class="kw">private class="kw">static void suggestOptionalArgNames(@Nonnull CommandSender var0, @Nonnull AbstractCommand var1, @Nonnull String var2, @Nonnull Set<String> var3) {
      for (Entry var5 : var1.getOptionalArguments().entrySet()) {
         if (var5.getValue().hasPermission(var0)) {
            String var6 = "--" + var5.getKey();
            if (startsWithIgnoreCase(var6, var2)) {
               var3.add(var6);
            }
         }
      }
   }

   class="kw">private class="kw">static void suggestArgValues(
      @Nonnull CommandSender var0, @Nonnull AbstractCommand var1, @Nonnull List<String> var2, int var3, int var4, @Nonnull Set<String> var5
   ) {
      int var6 = var4 - var3;
      if (var6 >= 0) {
         List var7 = var1.getRequiredArguments();
         List var8 = var1.getSuggestionOverrides();
         int var9 = 0;
         int var10 = 0;

         while (var10 < var7.size()) {
            RequiredArg var11 = var7.get(var10);
            ArgumentType var12 = var11.getArgumentType();
            AbstractCommand.SuggestionOverrideEntry var13 = overrideStartingAt(var8, var10);
            boolean var14 = var12.isGreedyString() || var12.isListArgument();
            int var15 = var13 != null ? var13.argCount() : Math.max(1, var12.getNumberOfParameters());
            if (var14 || var6 < var9 + var15) {
               String[] var16 = var2.subList(var3 + var9, var4 + 1).toArray(new String[0]);
               if (var13 != null) {
                  SuggestionResult var17 = new SuggestionResult();
                  var13.overrideType().suggest(var0, String.join(" ", var16), var16.length, var17);
                  var5.addAll(var17.getSuggestions());
               } else {
                  var5.addAll(var11.getSuggestions(var0, var16));
               }

               class="kw">return;
            }

            var9 += var15;
            var10 += var13 != null ? argsCovered(var7, var10, var15) : 1;
         }
      }
   }

   class="kw">private class="kw">static int lastOptionalTokenIndex(@Nonnull List<String> var0, int var1, int var2) {
      for (int var3 = var2 - 1; var3 >= var1; var3--) {
         if (ParserContext.isOptionalArgumentToken(var0.get(var3))) {
            class="kw">return var3;
         }
      }

      class="kw">return -1;
   }

   class="kw">private class="kw">static void suggestOptionalArgValues(
      @Nonnull CommandSender var0, @Nonnull AbstractCommand var1, @Nonnull List<String> var2, int var3, int var4, @Nonnull Set<String> var5
   ) {
      String var6 = var2.get(var3);
      String var7 = ParserContext.optionalArgumentName(var6);
      if (var7 != null) {
         AbstractOptionalArg var8 = (AbstractOptionalArg<? class="kw">extends Argument<?, ?>, ?>)var1.getOptionalArgument(var7);
         if (var8 != null && var8.hasPermission(var0)) {
            List var9 = var2.subList(var3 + 1, var4 + 1);
            String var10 = ParserContext.optionalArgumentInlineValue(var6);
            String[] var11;
            if (var10 != null) {
               var11 = new String[var9.size() + 1];
               var11[0] = var10;

               for (int var12 = 0; var12 < var9.size(); var12++) {
                  var11[var12 + 1] = var9.get(var12);
               }
            } else {
               var11 = var9.toArray(new String[0]);
            }

            var5.addAll(var8.getSuggestions(var0, var11));
         }
      }
   }

   class="kw">private class="kw">static void suggestInlineOptionalValue(
      @Nonnull CommandSender var0, @Nonnull AbstractCommand var1, @Nonnull String var2, int var3, @Nonnull Set<String> var4
   ) {
      String var5 = ParserContext.optionalArgumentName(var2);
      if (var5 != null) {
         AbstractOptionalArg var6 = (AbstractOptionalArg<? class="kw">extends Argument<?, ?>, ?>)var1.getOptionalArgument(var5);
         if (var6 != null && var6.hasPermission(var0)) {
            String var7 = var2.substring(0, var3 + 1);
            String var8 = var2.substring(var3 + 1);

            for (String var10 : var6.getSuggestions(var0, new String[]{var8})) {
               var4.add(var7 + var10);
            }
         }
      }
   }

   @Nullable
   class="kw">private class="kw">static AbstractCommand.SuggestionOverrideEntry overrideStartingAt(@Nullable List<AbstractCommand.SuggestionOverrideEntry> var0, int var1) {
      if (var0 == null) {
         class="kw">return null;
      }

      for (AbstractCommand.SuggestionOverrideEntry var3 : var0) {
         if (var3.argStart() == var1) {
            class="kw">return var3;
         }
      }

      class="kw">return null;
   }

   class="kw">private class="kw">static int argsCovered(@Nonnull List<RequiredArg<?>> var0, int var1, int var2) {
      int var3 = 0;

      int var4;
      for (var4 = 0; var1 + var4 < var0.size() && var3 < var2; var4++) {
         var3 += Math.max(1, var0.get(var1 + var4).getArgumentType().getNumberOfParameters());
      }

      class="kw">return Math.max(1, var4);
   }

   @Nonnull
   class="kw">private class="kw">static String stripSlash(@Nonnull String var0) {
      class="kw">return !var0.isEmpty() && var0.charAt(0) == '/' ? var0.substring(1) : var0;
   }

   class="kw">private class="kw">static boolean startsWithIgnoreCase(@Nonnull String var0, @Nonnull String var1) {
      class="kw">return var0.regionMatches(true, 0, var1, 0, var1.length());
   }
}