class="kw">package com.hypixel.hytale.builtin.commandmacro;

class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandContext;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandManager;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandSender;
class="kw">import com.hypixel.hytale.server.core.command.system.ParseResult;
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.DefaultArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.ArgumentType;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractAsyncCommand;
class="kw">import com.hypixel.hytale.server.core.console.ConsoleSender;
class="kw">import it.unimi.dsi.fastutil.Pair;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.logging.Level;
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 MacroCommandBase class="kw">extends AbstractAsyncCommand {
   @Nonnull
   class="kw">public class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   @Nonnull
   class="kw">private class="kw">static class="kw">final Pattern regexBracketPattern = Pattern.compile("\\{(.*?)}");
   @Nonnull
   class="kw">private class="kw">static class="kw">final Pattern PATTERN = Pattern.compile("\\\\\\{");
   @Nonnull
   class="kw">private class="kw">final Map<String, Argument<?, ?>> arguments = new Object2ObjectOpenHashMap();
   @Nonnull
   class="kw">private class="kw">final List<Pair<String, List<MacroCommandReplacement>>> commandReplacements = new ObjectArrayList();
   class="kw">private class="kw">final Map<String, String> defaultValueStrings = new Object2ObjectOpenHashMap();
   @Nonnull
   class="kw">private class="kw">final String fullPath;

   class="kw">public MacroCommandBase(
      @Nonnull String var1,
      @Nonnull String var2,
      @Nullable String[] var3,
      @Nonnull String var4,
      @Nullable MacroCommandParameter[] var5,
      @Nonnull String[] var6,
      @Nullable String var7
   ) {
      super(var1, var4);
      this.fullPath = var2;
      if (var7 != null) {
         if (var7.isEmpty()) {
            throw new IllegalArgumentException("Macro command '" + var2 + "' has an empty permissionGroup; remove the field or specify a valid group");
         }

         this.setPermissionGroups(var7);
      }

      if (var3 != null) {
         this.addAliases(var3);
      }

      if (var5 != null) {
         ParseResult var8 = new ParseResult();

         for (MacroCommandParameter var12 : var5) {
            Argument var13 = class="kw">switch (var12.getRequirement()) {
               case REQUIRED -> this.withRequiredArg(var12.getName(), var12.getDescription(), var12.getArgumentType().getArgumentType());
               case OPTIONAL -> this.withOptionalArg(var12.getName(), var12.getDescription(), var12.getArgumentType().getArgumentType());
               case FLAG -> this.withFlagArg(var12.getName(), var12.getDescription());
               case DEFAULT -> this.withDefaultArg(
                  var12.getName(),
                  var12.getDescription(),
                  var12.getArgumentType().getArgumentType(),
                  var12.getDefaultValue(),
                  var12.getDefaultValueDescription(),
                  var8
               );
            };
            this.arguments.put(var12.getName(), var13);
         }

         if (var8.failed()) {
            var8.sendMessages(ConsoleSender.INSTANCE);
            class="kw">return;
         }
      }

      Matcher var17 = regexBracketPattern.matcher("");

      for (int var18 = 0; var18 < var6.length; var18++) {
         String var19 = var6[var18];
         ObjectArrayList var21 = new ObjectArrayList();
         Matcher var22 = var17.reset(var19);

         while (var22.find()) {
            String var23 = var22.group(1);
            String[] var14 = var23.split(":", -1);
            if (var19.charAt(var17.start(1) - 2) != '\\') {
               String var15 = var19.substring(var17.start(1) - 1, var17.end(1) + 1);

               MacroCommandReplacement var16 = class="kw">switch (var14.length) {
                  case 1 -> new MacroCommandReplacement(var23, var15);
                  case 2 -> new MacroCommandReplacement(var14[1], var15, var14[0]);
                  class="kw">default -> throw new IllegalArgumentException("Cannot have more than one colon in a macro command parameter: '" + var23 + "'");
               };
               if (!this.arguments.containsKey(var16.getNameOfReplacingArg())) {
                  throw new IllegalArgumentException(
                     "Cannot define command with replacement token that does not refer to an argument: " + var16.getNameOfReplacingArg()
                  );
               }

               var21.add(var16);
            }
         }

         var19 = PATTERN.matcher(var19).replaceAll("{");
         var6[var18] = var19;
         this.commandReplacements.add(Pair.of(var19, var21));
      }
   }

   @Nullable
   class="kw">private <D> Argument<?, ?> withDefaultArg(
      String var1, String var2, @Nonnull ArgumentType<D> var3, @Nonnull String var4, String var5, @Nonnull ParseResult var6
   ) {
      Object var7 = var3.parse(var4.split(" ", 0), var6);
      if (var6.failed()) {
         LOGGER.at(Level.WARNING).log("Could not parse class="kw">default argument value for argument: '%s' on Macro Command: '%s'.", var1, this.getName());
         var6.sendMessages(ConsoleSender.INSTANCE);
         class="kw">return null;
      } else {
         this.defaultValueStrings.put(var1, var4);
         class="kw">return this.withDefaultArg(var1, var2, var3, var7, var5);
      }
   }

   @Nonnull
   @Override
   class="kw">protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext var1) {
      List var2 = new ObjectArrayList();
      CommandSender var3 = var1.sender();
      LOGGER.at(Level.INFO).log("%s expanding command macro: %s", var3.getUsername(), this.fullPath);

      for (Pair var5 : this.commandReplacements) {
         String var6 = (String)var5.key();

         for (MacroCommandReplacement var9 : (List)var5.value()) {
            String var10 = "";
            boolean var11 = true;
            Argument var12 = (Argument<? class="kw">extends Argument<?, ?>, ?>)this.arguments.get(var9.getNameOfReplacingArg());
            if (!(var12 class="kw">instanceof AbstractOptionalArg) || var1.provided(var12)) {
               var10 = String.join(" ", var1.getInput(this.arguments.get(var9.getNameOfReplacingArg())));
            } else if (var12 class="kw">instanceof DefaultArg) {
               var10 = this.defaultValueStrings.get(var12.getName());
            } else {
               var11 = false;
            }

            if (var11 && var9.getOptionalArgumentKey() != null) {
               var10 = var9.getOptionalArgumentKey() + var10;
            }

            var6 = var6.replace(var9.getStringToReplaceWithValue(), var11 ? var10 : "");
         }

         var2.add(var6);
      }

      CompletableFuture var13 = CompletableFuture.completedFuture(null);

      for (String var15 : var2) {
         var13 = var13.thenCompose(var2x -> CommandManager.get().handleCommand(var3, var15));
      }

      class="kw">return var13;
   }
}