class="kw">package com.hypixel.hytale.server.core.modules.accesscontrol;

class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.HytaleServerConfig;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.event.events.player.PlayerSetupConnectEvent;
class="kw">import com.hypixel.hytale.server.core.modules.accesscontrol.ban.Ban;
class="kw">import com.hypixel.hytale.server.core.modules.accesscontrol.commands.BanCommand;
class="kw">import com.hypixel.hytale.server.core.modules.accesscontrol.commands.UnbanCommand;
class="kw">import com.hypixel.hytale.server.core.modules.accesscontrol.commands.WhitelistCommand;
class="kw">import com.hypixel.hytale.server.core.modules.accesscontrol.provider.AccessProvider;
class="kw">import com.hypixel.hytale.server.core.modules.accesscontrol.provider.BanProvider;
class="kw">import com.hypixel.hytale.server.core.modules.accesscontrol.provider.JoinPermissionProvider;
class="kw">import com.hypixel.hytale.server.core.permissions.HytalePermissions;
class="kw">import com.hypixel.hytale.server.core.permissions.PermissionsModule;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import java.nio.file.Path;
class="kw">import java.util.Collection;
class="kw">import java.util.List;
class="kw">import java.util.Optional;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.CopyOnWriteArrayList;
class="kw">import java.util.concurrent.locks.ReentrantLock;
class="kw">import java.util.function.Supplier;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class AccessControlModule class="kw">extends JavaPlugin {
   class="kw">public class="kw">static class="kw">final PluginManifest MANIFEST = PluginManifest.corePlugin(AccessControlModule.class).depends(PermissionsModule.class).build();
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   @Nonnull
   class="kw">private class="kw">static class="kw">final CompletableFuture<Optional<Message>> NO_REASON_ANSWER = CompletableFuture.completedFuture(BanProvider.NO_REASON);
   class="kw">private class="kw">static AccessControlModule instance;
   class="kw">private class="kw">final AccessControlModule.ProviderSlot banSlot = new AccessControlModule.ProviderSlot();
   class="kw">private class="kw">final List<AccessProvider> providerRegistry = new CopyOnWriteArrayList<>(List.of(new JoinPermissionProvider()));

   class="kw">public class="kw">static AccessControlModule get() {
      class="kw">return instance;
   }

   class="kw">public AccessControlModule(@Nonnull JavaPluginInit var1) {
      super(var1);
      instance = this;
   }

   @Override
   class="kw">protected void setup() {
      this.getCommandRegistry().registerCommand(new BanCommand());
      this.getCommandRegistry().registerCommand(new UnbanCommand());
      this.getCommandRegistry().registerCommand(new WhitelistCommand());
      this.getEventRegistry().register(PlayerSetupConnectEvent.class, var1 -> {
         Optional var2;
         try {
            var2 = this.getDisconnectReason(var1.getUuid()).join();
         } catch (Throwable var4) {
            ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var4)).log("Failed to check the access of %s, refusing the connection", var1.getUuid());
            var2 = Optional.of(Message.translation("server.general.disconnect.internalServerError"));
         }

         if (var2.isPresent()) {
            var1.setReason(var2.get());
            var1.setCancelled(true);
         }
      });
   }

   @Override
   class="kw">protected void start() {
      this.banSlot.replaceIfUntouched(AccessControlModule::configuredBanProvider);
      this.banSlot.load();
      WhitelistMigration.run(Path.of("whitelist.json"), this);
   }

   @Override
   class="kw">protected void shutdown() {
      this.banSlot.save();
   }

   class="kw">public void registerAccessProvider(@Nonnull AccessProvider var1) {
      this.providerRegistry.add(var1);
   }

   @Nonnull
   class="kw">public BanProvider getBanProvider() {
      class="kw">return this.banSlot.get();
   }

   @Nonnull
   class="kw">private class="kw">static BanProvider configuredBanProvider() {
      class="kw">return HytaleServer.get().getConfig().getBanStorageProvider().getBanProvider();
   }

   @Nullable
   class="kw">public BanProvider setBanProvider(@Nonnull BanProvider var1) {
      class="kw">return this.banSlot.replace(var1);
   }

   class="kw">public boolean restoreBanProvider(@Nonnull BanProvider var1, @Nullable BanProvider var2) {
      class="kw">return this.banSlot.replaceIfCurrent(var1, var2 != null ? var2 : configuredBanProvider());
   }

   class="kw">public boolean isJoinPermissionRequired() {
      class="kw">return HytaleServer.get().getConfig().isRequireJoinPermission();
   }

   @Nonnull
   class="kw">public CompletableFuture<Void> setJoinPermissionRequired(boolean var1) {
      HytaleServerConfig var2 = HytaleServer.get().getConfig();
      boolean var3 = var2.isRequireJoinPermission();
      var2.setRequireJoinPermission(var1);
      class="kw">return HytaleServerConfig.save(var2).whenComplete((var2x, var3x) -> {
         if (var3x != null) {
            var2.setRequireJoinPermission(var3);
         }
      });
   }

   class="kw">public boolean allowJoin(@Nonnull UUID var1) {
      PermissionsModule var2 = PermissionsModule.get();
      if (var2.hasUserGrant(var1, HytalePermissions.SERVER_JOIN.getId())) {
         class="kw">return false;
      }

      var2.addUserPermission(var1, Set.of(HytalePermissions.SERVER_JOIN.getId()));
      class="kw">return true;
   }

   class="kw">public int allowJoin(@Nonnull Collection<UUID> var1) {
      class="kw">return PermissionsModule.get().addUserPermission(var1, Set.of(HytalePermissions.SERVER_JOIN.getId())).size();
   }

   class="kw">public boolean disallowJoin(@Nonnull UUID var1) {
      PermissionsModule var2 = PermissionsModule.get();
      if (!var2.hasUserGrant(var1, HytalePermissions.SERVER_JOIN.getId())) {
         class="kw">return false;
      }

      var2.removeUserPermission(var1, Set.of(HytalePermissions.SERVER_JOIN.getId()));
      class="kw">return true;
   }

   class="kw">public int disallowAllJoins() {
      class="kw">return PermissionsModule.get().removeUserPermissionFromAll(HytalePermissions.SERVER_JOIN.getId()).size();
   }

   class="kw">public boolean isAllowedToJoin(@Nonnull UUID var1) {
      class="kw">return PermissionsModule.get().hasPermission(var1, HytalePermissions.SERVER_JOIN);
   }

   @Nonnull
   class="kw">public Set<UUID> getUsersWithJoinGrant() {
      class="kw">return PermissionsModule.get().getUsersWithPermission(HytalePermissions.SERVER_JOIN.getId());
   }

   class="kw">private void swapInRegistry(@Nullable AccessProvider var1, @Nonnull AccessProvider var2) {
      for (int var3 = 0; var3 < this.providerRegistry.size(); var3++) {
         if (this.providerRegistry.get(var3) == var1) {
            this.providerRegistry.set(var3, var2);
            class="kw">return;
         }
      }

      this.providerRegistry.add(var2);
   }

   class="kw">public boolean isBanned(@Nonnull UUID var1) {
      class="kw">return this.banSlot.get().hasBan(var1);
   }

   class="kw">public boolean ban(@Nonnull Ban var1) {
      if (!var1.isInEffect()) {
         class="kw">return false;
      }

      if (!this.banSlot.addBan(var1)) {
         class="kw">return false;
      }

      PlayerRef var2 = Universe.get().getPlayer(var1.getTarget());
      if (var2 != null) {
         var2.getPacketHandler().disconnect(var1.getDisconnectReason());
      }

      class="kw">return true;
   }

   class="kw">public boolean unban(@Nonnull UUID var1) {
      class="kw">return this.banSlot.removeBan(var1);
   }

   @Nonnull
   class="kw">private CompletableFuture<Optional<Message>> getDisconnectReason(@Nonnull UUID var1) {
      for (int var2 = 0; var2 < this.providerRegistry.size(); var2++) {
         CompletableFuture var3 = this.providerRegistry.get(var2).getDisconnectReason(var1);
         if (!var3.isDone()) {
            class="kw">return this.awaitDisconnectReason(var1, var3, var2 + 1);
         }

         if (var3.join().isPresent()) {
            class="kw">return var3;
         }
      }

      class="kw">return NO_REASON_ANSWER;
   }

   @Nonnull
   class="kw">private CompletableFuture<Optional<Message>> awaitDisconnectReason(@Nonnull UUID var1, @Nonnull CompletableFuture<Optional<Message>> var2, int var3) {
      class="kw">return var2.thenCompose(
         var4 -> {
            if (var4.isPresent()) {
               class="kw">return var2;
            } else {
               class="kw">return var3 >= this.providerRegistry.size()
                  ? NO_REASON_ANSWER
                  : this.awaitDisconnectReason(var1, this.providerRegistry.get(var3).getDisconnectReason(var1), var3 + 1);
            }
         }
      );
   }

   class="kw">private class="kw">final class ProviderSlot {
      @Nonnull
      class="kw">private class="kw">final ReentrantLock lock = new ReentrantLock();
      @Nullable
      class="kw">private class="kw">volatile BanProvider provider;
      class="kw">private boolean loaded;
      class="kw">private boolean holdsState;
      class="kw">private boolean replaced;

      class="kw">private ProviderSlot() {
      }

      @Nonnull
      BanProvider get() {
         BanProvider var1 = this.provider;
         if (var1 == null) {
            throw new IllegalStateException("The server has not resolved its ban list yet, which it does when it starts");
         } else {
            class="kw">return var1;
         }
      }

      boolean addBan(@Nonnull Ban var1) {
         this.lock.lock();

         try {
            class="kw">return this.get().addBan(var1);
         } class="kw">finally {
            this.lock.unlock();
         }
      }

      boolean removeBan(@Nonnull UUID var1) {
         this.lock.lock();

         try {
            class="kw">return this.get().removeBan(var1);
         } class="kw">finally {
            this.lock.unlock();
         }
      }

      void load() {
         this.lock.lock();

         try {
            this.get().load();
            this.holdsState = true;
         } class="kw">finally {
            this.loaded = true;
            this.lock.unlock();
         }
      }

      void save() {
         this.lock.lock();

         try {
            if (this.holdsState && this.provider != null) {
               this.provider.save();
            }
         } class="kw">finally {
            this.lock.unlock();
         }
      }

      void replaceIfUntouched(@Nonnull Supplier<BanProvider> var1) {
         this.lock.lock();

         try {
            if (!this.replaced) {
               this.replace(var1.get());
            }
         } class="kw">finally {
            this.lock.unlock();
         }
      }

      boolean replaceIfCurrent(@Nonnull BanProvider var1, @Nonnull BanProvider var2) {
         this.lock.lock();

         try {
            if (this.provider != var1) {
               class="kw">return false;
            }

            this.replace(var2);
            class="kw">return true;
         } class="kw">finally {
            this.lock.unlock();
         }
      }

      @Nullable
      BanProvider replace(@Nonnull BanProvider var1) {
         this.lock.lock();

         try {
            BanProvider var2 = this.provider;
            this.replaced = true;
            if (var2 == var1) {
               class="kw">return var2;
            }

            if (this.loaded) {
               if (var2 != null && this.holdsState) {
                  try {
                     var2.save();
                  } catch (RuntimeException var7) {
                     ((HytaleLogger.Api)AccessControlModule.LOGGER.at(Level.WARNING).withCause(var7))
                        .log("Failed to save %s before replacing it", var2.getClass().getName());
                  }
               }

               var1.load();
               this.holdsState = true;
            }

            AccessControlModule.this.swapInRegistry(var2, var1);
            this.provider = var1;
            class="kw">return var2;
         } class="kw">finally {
            this.lock.unlock();
         }
      }
   }
}