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

class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.command.system.AbstractCommand;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandContext;
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.types.ArgumentType;
class="kw">import com.hypixel.hytale.server.core.permissions.PermissionQuery;
class="kw">import java.util.Collections;
class="kw">import java.util.HashSet;
class="kw">import java.util.Locale;
class="kw">import java.util.Set;
class="kw">import java.util.stream.Collectors;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">abstract class AbstractOptionalArg<Arg class="kw">extends Argument<Arg, DataType>, DataType> class="kw">extends Argument<Arg, DataType> {
   @Nonnull
   class="kw">private class="kw">final Set<String> aliases = new HashSet<>();
   @Nullable
   class="kw">private PermissionQuery permission;
   class="kw">private Set<AbstractOptionalArg<?, ?>> requiredIf;
   class="kw">private Set<AbstractOptionalArg<?, ?>> requiredIfAbsent;
   class="kw">private Set<AbstractOptionalArg<?, ?>> availableOnlyIfAll;
   class="kw">private Set<AbstractOptionalArg<?, ?>> availableOnlyIfAllAbsent;

   AbstractOptionalArg(@Nonnull AbstractCommand var1, @Nonnull String var2, @Nonnull String var3, @Nonnull ArgumentType<DataType> var4) {
      super(var1, var2, var3, var4);
   }

   class="kw">public class="kw">final Arg addAliases(@Nonnull String... var1) {
      if (this.getCommandRegisteredTo().hasBeenRegistered()) {
         throw new IllegalStateException("Cannot change aliases for an argument after a command has already been registered");
      }

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

      class="kw">return this.getThis();
   }

   class="kw">public Arg requiredIf(@Nonnull AbstractOptionalArg<?, ?> var1, @Nullable AbstractOptionalArg<?, ?>... var2) {
      if (this.requiredIf == null) {
         this.requiredIf = new HashSet<>();
      }

      if (!this.addDependencyArg(this.requiredIf, this.requiredIfAbsent, var1, var2)) {
         throw new IllegalStateException("Cannot have one argument in both requiredIf and requiredIfAbsent. Argument: " + var1.getName());
      } else {
         class="kw">return this.getThis();
      }
   }

   class="kw">public Arg requiredIf(@Nonnull AbstractOptionalArg<?, ?> var1) {
      class="kw">return this.requiredIf(var1, (AbstractOptionalArg<?, ?>[])null);
   }

   class="kw">public Arg requiredIfAbsent(@Nonnull AbstractOptionalArg<?, ?> var1, @Nullable AbstractOptionalArg<?, ?>... var2) {
      if (this.requiredIfAbsent == null) {
         this.requiredIfAbsent = new HashSet<>();
      }

      if (!this.addDependencyArg(this.requiredIfAbsent, this.requiredIf, var1, var2)) {
         throw new IllegalStateException("Cannot have one argument in both requiredIf and requiredIfAbsent. Argument: " + var1.getName());
      } else {
         class="kw">return this.getThis();
      }
   }

   class="kw">public Arg requiredIfAbsent(@Nonnull AbstractOptionalArg<?, ?> var1) {
      class="kw">return this.requiredIfAbsent(var1, (AbstractOptionalArg<?, ?>[])null);
   }

   class="kw">public Arg availableOnlyIfAll(@Nonnull AbstractOptionalArg<?, ?> var1, @Nullable AbstractOptionalArg<?, ?>... var2) {
      if (this.availableOnlyIfAll == null) {
         this.availableOnlyIfAll = new HashSet<>();
      }

      if (!this.addDependencyArg(this.availableOnlyIfAll, this.availableOnlyIfAllAbsent, var1, var2)) {
         throw new IllegalStateException("Cannot have one argument in both availableIf and availableIfAbsent. Argument: " + var1.getName());
      } else {
         class="kw">return this.getThis();
      }
   }

   class="kw">public Arg availableOnlyIfAll(@Nonnull AbstractOptionalArg<?, ?> var1) {
      class="kw">return this.availableOnlyIfAll(var1, (AbstractOptionalArg<?, ?>[])null);
   }

   class="kw">public Arg availableOnlyIfAllAbsent(@Nonnull AbstractOptionalArg<?, ?> var1, @Nullable AbstractOptionalArg<?, ?>... var2) {
      if (this.availableOnlyIfAllAbsent == null) {
         this.availableOnlyIfAllAbsent = new HashSet<>();
      }

      if (!this.addDependencyArg(this.availableOnlyIfAllAbsent, this.availableOnlyIfAll, var1, var2)) {
         throw new IllegalStateException("Cannot have one argument in both availableIf and availableIfAbsent. Argument: " + var1.getName());
      } else {
         class="kw">return this.getThis();
      }
   }

   class="kw">public Arg availableOnlyIfAllAbsent(@Nonnull AbstractOptionalArg<?, ?> var1) {
      class="kw">return this.availableOnlyIfAllAbsent(var1, (AbstractOptionalArg<?, ?>[])null);
   }

   class="kw">private boolean addDependencyArg(
      @Nonnull Set<AbstractOptionalArg<?, ?>> var1,
      @Nullable Set<AbstractOptionalArg<?, ?>> var2,
      AbstractOptionalArg<?, ?> var3,
      @Nullable AbstractOptionalArg<?, ?>... var4
   ) {
      if (this.getCommandRegisteredTo().hasBeenRegistered()) {
         throw new IllegalStateException("Cannot change argument dependencies after command has completed registration");
      }

      if (var2 != null && var2.contains(var3)) {
         class="kw">return false;
      }

      var1.add(var3);
      if (var4 != null) {
         if (var2 != null) {
            for (AbstractOptionalArg var8 : var4) {
               if (var2.contains(var8)) {
                  class="kw">return false;
               }
            }
         }

         Collections.addAll(this.requiredIfAbsent, var4);
      }

      class="kw">return true;
   }

   class="kw">public boolean verifyArgumentDependencies(@Nonnull CommandContext var1, @Nonnull ParseResult var2) {
      boolean var3 = var1.provided(this);
      if (!var3) {
         if (this.requiredIf != null) {
            for (AbstractOptionalArg var10 : this.requiredIf) {
               if (var10.provided(var1)) {
                  var2.fail(
                     Message.translation("server.commands.parsing.error.optionalArgRequiredIf")
                        .param("required", this.getName())
                        .param("requirer", var10.getName())
                  );
                  class="kw">return false;
               }
            }
         }

         if (this.requiredIfAbsent != null) {
            for (AbstractOptionalArg var11 : this.requiredIfAbsent) {
               if (!var11.provided(var1)) {
                  var2.fail(
                     Message.translation("server.commands.parsing.error.optionalArgRequiredIf")
                        .param("required", this.getName())
                        .param("requirer", var11.getName())
                  );
                  class="kw">return false;
               }
            }
         }

         class="kw">return true;
      } else {
         if (this.availableOnlyIfAll != null) {
            for (AbstractOptionalArg var5 : this.availableOnlyIfAll) {
               if (!var5.provided(var1)) {
                  var2.fail(
                     Message.translation("server.commands.parsing.error.optionalArgAvailableIf")
                        .param("available", this.getName())
                        .param("required", this.availableOnlyIfAll.stream().map(Argument::getName).collect(Collectors.joining(", ")))
                  );
                  class="kw">return false;
               }
            }
         }

         if (this.availableOnlyIfAllAbsent != null) {
            for (AbstractOptionalArg var9 : this.availableOnlyIfAllAbsent) {
               if (var9.provided(var1)) {
                  var2.fail(
                     Message.translation("server.commands.parsing.error.optionalArgAvailableIfAbsent")
                        .param("available", this.getName())
                        .param("required", this.availableOnlyIfAllAbsent.stream().map(Argument::getName).collect(Collectors.joining(", ")))
                  );
                  class="kw">return false;
               }
            }
         }

         class="kw">return true;
      }
   }

   @Nonnull
   class="kw">public Arg setPermission(@Nonnull String var1) {
      if (this.getCommandRegisteredTo().hasBeenRegistered()) {
         throw new IllegalStateException("Cannot change permissions after a command has already been registered");
      }

      this.permission = PermissionQuery.of(var1);
      class="kw">return this.getThis();
   }

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

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

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

   class="kw">public class="kw">interface DefaultValueArgument<DataType> {
      DataType getDefaultValue();
   }
}