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

class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import it.unimi.dsi.fastutil.booleans.BooleanArrayList;
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.objects.Object2ObjectLinkedOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectSortedSet;
class="kw">import java.util.HashSet;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.regex.Matcher;
class="kw">import java.util.regex.Pattern;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class ParserContext {
   class="kw">private class="kw">static class="kw">final HashSet<String> SPECIAL_TOKENS = new HashSet<>(
      List.of(Tokenizer.MULTI_ARG_BEGIN, Tokenizer.MULTI_ARG_END, Tokenizer.MULTI_ARG_SEPARATOR)
   );
   class="kw">private class="kw">static class="kw">final int MAX_LIST_ITEMS = 10;
   @Nonnull
   class="kw">private class="kw">final String inputString;
   @Nonnull
   class="kw">private class="kw">final String rawInput;
   @Nonnull
   class="kw">private class="kw">final BooleanArrayList parameterForwardingMap;
   @Nonnull
   class="kw">private class="kw">final Int2ObjectMap<String> preOptionalSingleValueTokens;
   @Nonnull
   class="kw">private class="kw">final Int2ObjectMap<ParserContext.PreOptionalListContext> preOptionalListTokens;
   @Nonnull
   class="kw">private class="kw">final Object2ObjectLinkedOpenHashMap<String, List<List<String>>> optionalArgs;
   class="kw">private String lastInsertedOptionalArgName;
   class="kw">private int numPreOptSingleValueTokensBeforeListTokens;
   class="kw">private int subCommandIndex;
   class="kw">private class="kw">static class="kw">final Pattern ARG_NAME_PATTERN = Pattern.compile("--([\\w-]*)");
   class="kw">private class="kw">static class="kw">final Pattern ARG_NAME_AND_VALUE_PATTERN = Pattern.compile("--([\\w-]+)=(.+)");

   class="kw">public ParserContext(@Nonnull List<String> var1, @Nonnull String var2, @Nonnull ParseResult var3) {
      this.inputString = String.join(" ", var1);
      this.rawInput = var2;
      this.parameterForwardingMap = new BooleanArrayList();
      this.preOptionalSingleValueTokens = new Int2ObjectOpenHashMap();
      this.preOptionalListTokens = new Int2ObjectOpenHashMap();
      this.optionalArgs = new Object2ObjectLinkedOpenHashMap();
      this.contextualizeTokens(var1, var3);
   }

   @Nonnull
   class="kw">public class="kw">static ParserContext of(@Nonnull List<String> var0, @Nonnull String var1, @Nonnull ParseResult var2) {
      class="kw">return new ParserContext(var0, var1, var2);
   }

   class="kw">public class="kw">static boolean isOptionalArgumentToken(@Nonnull String var0) {
      class="kw">return ARG_NAME_PATTERN.matcher(var0).lookingAt();
   }

   @Nullable
   class="kw">public class="kw">static String optionalArgumentName(@Nonnull String var0) {
      Matcher var1 = ARG_NAME_PATTERN.matcher(var0);
      class="kw">return var1.lookingAt() ? var1.group(1) : null;
   }

   @Nullable
   class="kw">public class="kw">static String optionalArgumentInlineValue(@Nonnull String var0) {
      Matcher var1 = ARG_NAME_AND_VALUE_PATTERN.matcher(var0);
      class="kw">return var1.matches() ? stripSurroundingQuotes(var1.group(2)) : null;
   }

   @Nonnull
   class="kw">private class="kw">static String stripSurroundingQuotes(@Nonnull String var0) {
      if (var0.length() >= 2) {
         char var1 = var0.charAt(0);
         char var2 = var0.charAt(var0.length() - 1);
         if (var1 == '"' && var2 == '"' || var1 == '\'' && var2 == '\'') {
            class="kw">return var0.substring(1, var0.length() - 1);
         }
      }

      class="kw">return var0;
   }

   class="kw">private void contextualizeTokens(@Nonnull List<String> var1, @Nonnull ParseResult var2) {
      boolean var3 = false;
      boolean var4 = false;
      boolean var5 = false;
      boolean var6 = false;
      boolean var7 = false;
      Matcher var8 = ARG_NAME_PATTERN.matcher("");
      Matcher var9 = ARG_NAME_AND_VALUE_PATTERN.matcher("");

      for (int var10 = 0; var10 < var1.size(); var10++) {
         String var11 = var1.get(var10);
         if (var4) {
            var7 = true;
         }

         if (SPECIAL_TOKENS.contains(var11)) {
            boolean var12 = var1.get(var10 - 1).equals(Tokenizer.MULTI_ARG_END) && !var4 && var11.equals(Tokenizer.MULTI_ARG_BEGIN);
            if (var6 && !var12) {
               StringBuilder var13 = new StringBuilder();

               for (int var14 = 0; var14 < var1.size(); var14++) {
                  var13.append(var1.get(var14)).append(" ");
                  if (var14 == var10) {
                     var13.append(" <--- *HERE!* ");
                  }
               }

               var2.fail(Message.translation("server.commands.parsing.error.cantDoublePlaceSpecialTokens"), Message.raw(var13.toString()));
               class="kw">return;
            }

            var6 = true;
         } else {
            var6 = false;
         }

         var8.reset(var11);
         if (var8.lookingAt()) {
            var3 = true;
            this.addNewOptionalArg(var8.group(1));
            var9.reset(var11);
            if (var9.matches()) {
               String var15 = stripSurroundingQuotes(var9.group(2));
               this.appendOptionalParameter(var15, var2);
               if (var2.failed()) {
                  class="kw">return;
               }
            }
         } else if (var3) {
            this.appendOptionalParameter(var11, var2);
            if (var2.failed()) {
               class="kw">return;
            }
         } else if (var11.equals(Tokenizer.MULTI_ARG_BEGIN)) {
            var4 = true;
            var5 = false;
            this.parameterForwardingMap.add(true);
            this.preOptionalListTokens.put(this.parameterForwardingMap.size() - 1, new ParserContext.PreOptionalListContext());
         } else if (var11.equals(Tokenizer.MULTI_ARG_END)) {
            var4 = false;
         } else if (var4) {
            ((ParserContext.PreOptionalListContext)this.preOptionalListTokens.get(this.parameterForwardingMap.size() - 1)).addToken(var11, var2);
            if (var2.failed()) {
               class="kw">return;
            }

            if (var5 && !var6 && var1.size() > var10 + 1 && !var1.get(var10 + 1).equals(Tokenizer.MULTI_ARG_SEPARATOR)) {
               var4 = false;
            }
         } else if (var1.size() > var10 + 1 && var1.get(var10 + 1).equals(Tokenizer.MULTI_ARG_SEPARATOR)) {
            var4 = true;
            var5 = true;
            this.parameterForwardingMap.add(true);
            this.preOptionalListTokens.put(this.parameterForwardingMap.size() - 1, new ParserContext.PreOptionalListContext().addToken(var11, var2));
            if (var2.failed()) {
               class="kw">return;
            }
         } else {
            if (!var7) {
               this.numPreOptSingleValueTokensBeforeListTokens++;
            }

            this.parameterForwardingMap.add(false);
            this.preOptionalSingleValueTokens.put(this.parameterForwardingMap.size() - 1, var11);
         }
      }

      if (var4 && !var5) {
         var2.fail(Message.translation("server.commands.parsing.error.endCommandWithOpenList").param("listEndToken", Tokenizer.MULTI_ARG_END));
      }
   }

   class="kw">public void addNewOptionalArg(String var1) {
      var1 = var1.toLowerCase(Locale.ROOT);
      this.lastInsertedOptionalArgName = var1;
      this.optionalArgs.put(var1, new ObjectArrayList());
   }

   class="kw">public void appendOptionalParameter(@Nonnull String var1, @Nonnull ParseResult var2) {
      if (!this.optionalArgs.isEmpty() && this.lastInsertedOptionalArgName != null) {
         List var3 = (List<List<String>>)this.optionalArgs.get(this.lastInsertedOptionalArgName);
         if (!var1.equals(Tokenizer.MULTI_ARG_BEGIN) && !var1.equals(Tokenizer.MULTI_ARG_END)) {
            if (var1.equals(Tokenizer.MULTI_ARG_SEPARATOR)) {
               var3.add(new ObjectArrayList());
            } else if (var3.isEmpty()) {
               ObjectArrayList var4 = new ObjectArrayList();
               var4.add(var1);
               var3.add(var4);
            } else {
               var3.getLast().add(var1);
            }
         }
      } else {
         var2.fail(Message.translation("server.commands.parsing.error.noOptionalParameterToAddValueTo"));
      }
   }

   @Nonnull
   class="kw">public String getInputString() {
      class="kw">return this.inputString;
   }

   @Nonnull
   class="kw">public String getRawInput() {
      class="kw">return this.rawInput;
   }

   class="kw">public int getSubCommandIndex() {
      class="kw">return this.subCommandIndex;
   }

   class="kw">public boolean isListToken(int var1) {
      var1 += this.subCommandIndex;
      class="kw">return this.parameterForwardingMap.size() <= var1 ? false : this.parameterForwardingMap.getBoolean(var1);
   }

   class="kw">public int getNumPreOptSingleValueTokensBeforeListTokens() {
      class="kw">return this.numPreOptSingleValueTokensBeforeListTokens - this.subCommandIndex;
   }

   class="kw">public int getNumPreOptionalTokens() {
      int var1 = 0;
      var1 += this.preOptionalSingleValueTokens.size();
      ObjectIterator var2 = this.preOptionalListTokens.values().iterator();

      while (var2.hasNext()) {
         ParserContext.PreOptionalListContext var3 = (ParserContext.PreOptionalListContext)var2.next();
         var1 += var3.numTokensPerArgument;
      }

      class="kw">return var1 - this.subCommandIndex;
   }

   class="kw">public String getPreOptionalSingleValueToken(int var1) {
      var1 += this.subCommandIndex;
      class="kw">return (String)this.preOptionalSingleValueTokens.get(var1);
   }

   class="kw">public ParserContext.PreOptionalListContext getPreOptionalListToken(int var1) {
      var1 += this.subCommandIndex;
      class="kw">return (ParserContext.PreOptionalListContext)this.preOptionalListTokens.get(var1);
   }

   @Nullable
   class="kw">public String getFirstToken() {
      if (this.parameterForwardingMap.size() <= this.subCommandIndex) {
         class="kw">return null;
      } else if (this.parameterForwardingMap.getBoolean(this.subCommandIndex)) {
         ParserContext.PreOptionalListContext var1 = (ParserContext.PreOptionalListContext)this.preOptionalListTokens.get(this.subCommandIndex);
         class="kw">return var1.tokens.isEmpty() ? null : var1.tokens.getFirst();
      } else {
         class="kw">return (String)this.preOptionalSingleValueTokens.get(this.subCommandIndex);
      }
   }

   @Nonnull
   class="kw">public ObjectSortedSet<Entry<String, List<List<String>>>> getOptionalArgs() {
      class="kw">return this.optionalArgs.entrySet();
   }

   class="kw">public boolean isHelpSpecified() {
      class="kw">return this.optionalArgs.containsKey("help") || this.optionalArgs.containsKey("?");
   }

   class="kw">public boolean isConfirmationSpecified() {
      class="kw">return this.optionalArgs.containsKey("confirm");
   }

   class="kw">public void convertToSubCommand() {
      this.subCommandIndex++;
   }

   class="kw">public class="kw">static class PreOptionalListContext {
      class="kw">private class="kw">final List<String> tokens = new ObjectArrayList();
      class="kw">private boolean hasReachedFirstMultiArgSeparator = false;
      class="kw">private int numTokensPerArgument = 0;
      class="kw">private int numTokensSinceLastSeparator = 0;
      class="kw">private int numberOfListItems = 0;

      class="kw">public PreOptionalListContext() {
      }

      @Nullable
      class="kw">public ParserContext.PreOptionalListContext addToken(@Nonnull String var1, @Nonnull ParseResult var2) {
         if (var1.equals(Tokenizer.MULTI_ARG_SEPARATOR)) {
            if (!this.hasReachedFirstMultiArgSeparator) {
               this.hasReachedFirstMultiArgSeparator = true;
               this.numTokensSinceLastSeparator = 0;
               this.numberOfListItems++;
               this.verifyNumberOfListItems(var2);
               class="kw">return this;
            } else if (this.numTokensSinceLastSeparator != this.numTokensPerArgument) {
               this.tokens.add(var1);
               var2.fail(
                  Message.translation("server.commands.parsing.error.allArgumentsInListNeedSameLength").param("error", this.getStringRepresentation(true))
               );
               class="kw">return null;
            } else {
               this.numTokensSinceLastSeparator = 0;
               this.numberOfListItems++;
               this.verifyNumberOfListItems(var2);
               class="kw">return this;
            }
         } else {
            this.numTokensSinceLastSeparator++;
            if (this.numberOfListItems == 0) {
               this.numTokensPerArgument++;
            }

            if (this.hasReachedFirstMultiArgSeparator && this.numTokensSinceLastSeparator > this.numTokensPerArgument) {
               this.tokens.add(var1);
               var2.fail(
                  Message.translation("server.commands.parsing.error.allArgumentsInListNeedSameLength").param("error", this.getStringRepresentation(true))
               );
               class="kw">return null;
            } else {
               this.tokens.add(var1);
               class="kw">return this;
            }
         }
      }

      @Nonnull
      class="kw">private String getStringRepresentation(boolean var1) {
         StringBuilder var2 = new StringBuilder(Tokenizer.MULTI_ARG_BEGIN);

         for (int var3 = 0; var3 < this.tokens.size(); var3++) {
            if (var3 != 0 && var3 % this.numTokensPerArgument == 0 && var3 != this.tokens.size() - 1) {
               var2.append(" ").append(Tokenizer.MULTI_ARG_SEPARATOR);
            }

            var2.append(" ").append(this.tokens.get(var3));
         }

         if (var1) {
            var2.append("<-- *HERE* ... ]");
         } else {
            var2.append(" ]");
         }

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

      class="kw">public void verifyNumberOfListItems(@Nonnull ParseResult var1) {
         if (this.numberOfListItems > 10) {
            var1.fail(Message.translation("server.commands.parsing.error.tooManyListItems").param("amount", 10));
         }
      }

      @Nonnull
      class="kw">public String[] getTokens() {
         class="kw">return this.tokens.toArray(String[]::new);
      }

      class="kw">public int getNumTokensPerArgument() {
         class="kw">return this.numTokensPerArgument;
      }

      class="kw">public int getNumberOfListItems() {
         class="kw">return this.numberOfListItems;
      }
   }
}