class="kw">package com.hypixel.hytale.server.core.permissions.provider;

class="kw">import com.google.gson.Gson;
class="kw">import com.google.gson.GsonBuilder;
class="kw">import com.google.gson.JsonArray;
class="kw">import com.google.gson.JsonElement;
class="kw">import com.google.gson.JsonObject;
class="kw">import com.google.gson.JsonParser;
class="kw">import com.google.gson.stream.JsonReader;
class="kw">import com.google.gson.stream.JsonWriter;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.permissions.PermissionValidation;
class="kw">import com.hypixel.hytale.server.core.util.io.BlockingDiskFile;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import java.io.BufferedReader;
class="kw">import java.io.BufferedWriter;
class="kw">import java.io.IOException;
class="kw">import java.nio.file.Path;
class="kw">import java.nio.file.Paths;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Collection;
class="kw">import java.util.Collections;
class="kw">import java.util.HashMap;
class="kw">import java.util.HashSet;
class="kw">import java.util.LinkedHashMap;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.Map.Entry;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">final class HytalePermissionsProvider class="kw">extends BlockingDiskFile class="kw">implements PermissionProvider {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">public class="kw">static class="kw">final String GROUP_NONE = "hytale:None";
   class="kw">public class="kw">static class="kw">final String GROUP_ADVENTURER = "hytale:Adventurer";
   class="kw">public class="kw">static class="kw">final String GROUP_BUILDER = "hytale:Builder";
   class="kw">public class="kw">static class="kw">final String GROUP_WORLD_EDITOR = "hytale:WorldEditor";
   class="kw">public class="kw">static class="kw">final String GROUP_SERVER_EDITOR = "hytale:ServerEditor";
   class="kw">public class="kw">static class="kw">final String GROUP_ADMIN = "hytale:Admin";
   @Nonnull
   class="kw">public class="kw">static class="kw">final String DEFAULT_GROUP = "hytale:Adventurer";
   @Deprecated
   @Nonnull
   class="kw">public class="kw">static class="kw">final String OP_GROUP = "hytale:Admin";
   @Nonnull
   class="kw">public class="kw">static class="kw">final Set<String> DEFAULT_GROUP_LIST = Set.of("hytale:Adventurer");
   class="kw">private class="kw">static class="kw">final Map<String, String> LEGACY_GROUP_MAPPINGS;
   @Nonnull
   class="kw">private class="kw">static class="kw">final Map<String, HytalePermissionsProvider.GroupData> BUILTIN_GROUPS;
   @Nonnull
   class="kw">private class="kw">static class="kw">final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
   @Nonnull
   class="kw">public class="kw">static class="kw">final String PERMISSIONS_FILE_PATH = "permissions.json";
   @Nonnull
   class="kw">private class="kw">volatile HytalePermissionsProvider.State state = new HytalePermissionsProvider.State(Map.of(), Map.of(), Map.of());

   @Nonnull
   class="kw">public class="kw">static String resolveGroupName(@Nonnull String var0) {
      String var1 = LEGACY_GROUP_MAPPINGS.get(var0.toLowerCase(Locale.ROOT));
      class="kw">return var1 != null ? var1 : var0;
   }

   class="kw">public HytalePermissionsProvider() {
      super(Paths.get("permissions.json"));
   }

   class="kw">public HytalePermissionsProvider(@Nonnull Path var1) {
      super(var1);
   }

   @Nonnull
   @Override
   class="kw">public String getName() {
      class="kw">return "HytalePermissionsProvider";
   }

   @Override
   class="kw">public void addUserPermissions(@Nonnull UUID var1, @Nonnull Set<String> var2) {
      this.fileLock.writeLock().lock();

      try {
         HytalePermissionsProvider.State var3 = this.state;
         Set var4 = new HashSet<>(var3.userPermissions.getOrDefault(var1, Set.of()));
         if (var4.addAll(var2)) {
            this.state = var3.withUserPermissions(var1, var4);
            this.save(var3);
         }
      } class="kw">finally {
         this.fileLock.writeLock().unlock();
      }
   }

   @Override
   class="kw">public void removeUserPermissions(@Nonnull UUID var1, @Nonnull Set<String> var2) {
      this.fileLock.writeLock().lock();

      try {
         HytalePermissionsProvider.State var3 = this.state;
         Set var4 = var3.userPermissions.get(var1);
         if (var4 != null) {
            Set var5 = new HashSet<>(var4);
            if (var5.removeAll(var2)) {
               this.state = var3.withUserPermissions(var1, var5);
               this.save(var3);
            }

            class="kw">return;
         }
      } class="kw">finally {
         this.fileLock.writeLock().unlock();
      }
   }

   @Nonnull
   @Override
   class="kw">public Set<String> getUserPermissions(@Nonnull UUID var1) {
      Set var2 = this.state.userPermissions.get(var1);
      class="kw">return var2 == null ? Set.of() : var2;
   }

   @Nonnull
   @Override
   class="kw">public Set<UUID> getUsersWithPermission(@Nonnull String var1) {
      Set var2 = null;

      for (Entry var4 : this.state.userPermissions.entrySet()) {
         if (var4.getValue().contains(var1)) {
            if (var2 == null) {
               var2 = new HashSet<>();
            }

            var2.add(var4.getKey());
         }
      }

      class="kw">return var2 == null ? Collections.emptySet() : Collections.unmodifiableSet(var2);
   }

   @Nonnull
   @Override
   class="kw">public Set<UUID> addUserPermissions(@Nonnull Collection<UUID> var1, @Nonnull Set<String> var2) {
      this.fileLock.writeLock().lock();

      try {
         HytalePermissionsProvider.State var3 = this.state;
         Map var4 = new HashMap<>(var3.userPermissions);
         Set var5 = new HashSet<>();

         for (UUID var7 : var1) {
            Set var8 = new HashSet<>(var4.getOrDefault(var7, Set.of()));
            if (var8.addAll(var2)) {
               var4.put(var7, Set.copyOf(var8));
               var5.add(var7);
            }
         }

         if (!var5.isEmpty()) {
            this.state = new HytalePermissionsProvider.State(var4, var3.groupData, var3.userGroups);
            this.save(var3);
         }

         class="kw">return var5;
      } class="kw">finally {
         this.fileLock.writeLock().unlock();
      }
   }

   @Nonnull
   @Override
   class="kw">public Set<UUID> removeUserPermissionFromAll(@Nonnull String var1) {
      this.fileLock.writeLock().lock();

      try {
         HytalePermissionsProvider.State var2 = this.state;
         Map var3 = new HashMap<>(var2.userPermissions);
         Set var4 = new HashSet<>();

         for (Entry var6 : var2.userPermissions.entrySet()) {
            if (var6.getValue().contains(var1)) {
               Set var7 = new HashSet<>(var6.getValue());
               var7.remove(var1);
               var4.add(var6.getKey());
               if (var7.isEmpty()) {
                  var3.remove(var6.getKey());
               } else {
                  var3.put(var6.getKey(), Set.copyOf(var7));
               }
            }
         }

         if (!var4.isEmpty()) {
            this.state = new HytalePermissionsProvider.State(var3, var2.groupData, var2.userGroups);
            this.save(var2);
         }

         class="kw">return var4;
      } class="kw">finally {
         this.fileLock.writeLock().unlock();
      }
   }

   class="kw">private void save(@Nonnull HytalePermissionsProvider.State var1) {
      try {
         this.syncSave();
      } catch (RuntimeException | Error var3) {
         this.state = var1;
         throw var3;
      }
   }

   @Override
   class="kw">public void addGroupPermissions(@Nonnull String var1, @Nonnull Set<String> var2) {
      this.fileLock.writeLock().lock();

      try {
         HytalePermissionsProvider.State var3 = this.state;
         HytalePermissionsProvider.GroupData var4 = var3.groupData.get(var1);
         Set var5 = new HashSet<>(var4 == null ? Set.of() : var4.permissions);
         if (var5.addAll(var2)) {
            Map var6 = new HashMap<>(var3.groupData);
            var6.put(var1, new HytalePermissionsProvider.GroupData(var4 == null ? null : var4.parent, var5));
            this.state = new HytalePermissionsProvider.State(var3.userPermissions, var6, var3.userGroups);
            this.save(var3);
         }
      } class="kw">finally {
         this.fileLock.writeLock().unlock();
      }
   }

   @Override
   class="kw">public void removeGroupPermissions(@Nonnull String var1, @Nonnull Set<String> var2) {
      this.fileLock.writeLock().lock();

      try {
         HytalePermissionsProvider.State var3 = this.state;
         HytalePermissionsProvider.GroupData var4 = var3.groupData.get(var1);
         if (var4 == null) {
            class="kw">return;
         }

         Set var5 = new HashSet<>(var4.permissions);
         if (var5.removeAll(var2)) {
            Map var6 = new HashMap<>(var3.groupData);
            if (var5.isEmpty() && var4.parent == null && !BUILTIN_GROUPS.containsKey(var1)) {
               var6.remove(var1);
            } else {
               var6.put(var1, new HytalePermissionsProvider.GroupData(var4.parent, var5));
            }

            this.state = new HytalePermissionsProvider.State(var3.userPermissions, var6, var3.userGroups);
            this.save(var3);
            class="kw">return;
         }
      } class="kw">finally {
         this.fileLock.writeLock().unlock();
      }
   }

   @Nonnull
   @Override
   class="kw">public Set<String> getGroupPermissions(@Nonnull String var1) {
      HytalePermissionsProvider.GroupData var2 = this.state.groupData.get(var1);
      class="kw">return var2 == null ? Set.of() : var2.permissions;
   }

   @Nullable
   @Override
   class="kw">public String getGroupParent(@Nonnull String var1) {
      HytalePermissionsProvider.GroupData var2 = this.state.groupData.get(var1);
      class="kw">return var2 != null ? var2.parent : null;
   }

   @Nonnull
   @Override
   class="kw">public Set<String> getAllRegisteredGroups() {
      class="kw">return this.state.groupData.keySet();
   }

   @Nonnull
   @Override
   class="kw">public Set<String> getEffectiveGroupPermissions(@Nonnull String var1) {
      Map var2 = this.state.groupData;
      List var3 = new ArrayList<>();
      Set var4 = new HashSet<>();
      String var5 = var1;

      while (var5 != null && var4.add(var5)) {
         HytalePermissionsProvider.GroupData var6 = var2.get(var5);
         if (var6 == null) {
            break;
         }

         var3.add(var6.permissions);
         var5 = var6.parent;
      }

      Set var13 = new HashSet<>();
      Set var7 = new HashSet<>();

      for (Set var9 : var3) {
         for (String var11 : var9) {
            String var12 = var11.startsWith("-") ? var11.substring(1) : var11;
            if (var7.add(var12)) {
               var13.add(var11);
            }
         }
      }

      class="kw">return Collections.unmodifiableSet(var13);
   }

   @Override
   class="kw">public void addUserToGroup(@Nonnull UUID var1, @Nonnull String var2) {
      this.fileLock.writeLock().lock();

      try {
         HytalePermissionsProvider.State var3 = this.state;
         Set var4 = new HashSet<>(var3.userGroups.getOrDefault(var1, Set.of()));
         if (var4.add(var2)) {
            this.state = var3.withUserGroups(var1, var4);
            this.save(var3);
         }
      } class="kw">finally {
         this.fileLock.writeLock().unlock();
      }
   }

   @Override
   class="kw">public void removeUserFromGroup(@Nonnull UUID var1, @Nonnull String var2) {
      this.fileLock.writeLock().lock();

      try {
         HytalePermissionsProvider.State var3 = this.state;
         Set var4 = var3.userGroups.get(var1);
         if (var4 != null) {
            Set var5 = new HashSet<>(var4);
            if (var5.remove(var2)) {
               this.state = var3.withUserGroups(var1, var5);
               this.save(var3);
            }

            class="kw">return;
         }
      } class="kw">finally {
         this.fileLock.writeLock().unlock();
      }
   }

   @Nonnull
   @Override
   class="kw">public Set<String> getGroupsForUser(@Nonnull UUID var1) {
      Set var2 = this.state.userGroups.get(var1);
      class="kw">return var2 == null ? DEFAULT_GROUP_LIST : var2;
   }

   @Override
   class="kw">public void setUserGroup(@Nonnull UUID var1, @Nonnull String var2) {
      this.fileLock.writeLock().lock();

      try {
         HytalePermissionsProvider.State var3 = this.state;
         this.state = var3.withUserGroups(var1, Set.of(var2));
         this.save(var3);
      } class="kw">finally {
         this.fileLock.writeLock().unlock();
      }
   }

   @Override
   class="kw">protected void read(@Nonnull BufferedReader var1) class="kw">throws IOException {
      JsonReader var2 = new JsonReader(var1);

      try {
         JsonObject var3 = JsonParser.parseReader(var2).getAsJsonObject();
         Map var4 = new HashMap<>();
         Map var5 = new HashMap<>();
         Map var6 = new HashMap<>();
         if (var3.has("users")) {
            JsonObject var7 = var3.getAsJsonObject("users");

            for (Entry var9 : var7.entrySet()) {
               UUID var10 = UUID.fromString(var9.getKey());
               JsonObject var11 = var9.getValue().getAsJsonObject();
               if (var11.has("permissions")) {
                  Set var12 = new HashSet<>();
                  var4.put(var10, var12);
                  var11.getAsJsonArray("permissions").forEach(var2x -> {
                     String var3 = var2x.getAsString();
                     if (PermissionValidation.isValidPermissionNode(var3)) {
                        var12.add(var3);
                     } else {
                        ((HytaleLogger.Api)LOGGER.atWarning()).log("Skipping invalid user permission node '%s' for %s", var3, var10);
                     }
                  });
               }

               if (var11.has("groups")) {
                  Set var26 = new HashSet<>();
                  var6.put(var10, var26);
                  var11.getAsJsonArray("groups").forEach(var2x -> {
                     String var3 = resolveGroupName(var2x.getAsString());
                     if (PermissionValidation.isValidGroupName(var3)) {
                        var26.add(var3);
                     } else {
                        ((HytaleLogger.Api)LOGGER.atWarning()).log("Skipping invalid group name '%s' for user %s", var3, var10);
                     }
                  });
               }
            }
         }

         if (var3.has("groups")) {
            JsonObject var17 = var3.getAsJsonObject("groups");

            for (Entry var21 : var17.entrySet()) {
               String var23 = resolveGroupName(var21.getKey());
               if (!PermissionValidation.isValidGroupName(var23)) {
                  ((HytaleLogger.Api)LOGGER.atWarning()).log("Skipping invalid group name '%s' in permissions.json", var21.getKey());
               } else {
                  JsonElement var25 = var21.getValue();
                  if (var25.isJsonArray()) {
                     Set var27 = new HashSet<>();
                     var25.getAsJsonArray().forEach(var2x -> addValidatedPermission(var27, var2x.getAsString(), var23));
                     var5.put(var23, new HytalePermissionsProvider.GroupData(null, var27));
                     ((HytaleLogger.Api)LOGGER.atInfo()).log("Migrated legacy group format for '%s'", var21.getKey());
                  } else if (var25.isJsonObject()) {
                     JsonObject var28 = var25.getAsJsonObject();
                     String var13 = null;
                     if (var28.has("parent")) {
                        String var14 = resolveGroupName(var28.get("parent").getAsString());
                        if (PermissionValidation.isValidGroupName(var14)) {
                           var13 = var14;
                        } else {
                           ((HytaleLogger.Api)LOGGER.atWarning()).log("Skipping invalid parent '%s' for group '%s'", var14, var23);
                        }
                     }

                     Set var29 = new HashSet<>();
                     if (var28.has("permissions")) {
                        var28.getAsJsonArray("permissions").forEach(var2x -> addValidatedPermission(var29, var2x.getAsString(), var23));
                     }

                     var5.put(var23, new HytalePermissionsProvider.GroupData(var13, var29));
                  }
               }
            }
         }

         for (Entry var20 : BUILTIN_GROUPS.entrySet()) {
            HytalePermissionsProvider.GroupData var22 = var5.get(var20.getKey());
            if (var22 == null) {
               var5.put(var20.getKey(), var20.getValue());
            } else {
               Set var24 = new HashSet<>(var20.getValue().permissions);
               var24.addAll(var22.permissions);
               var5.put(var20.getKey(), new HytalePermissionsProvider.GroupData(var20.getValue().parent, var24));
            }
         }

         this.state = HytalePermissionsProvider.State.frozen(var4, var5, var6);
      } catch (Throwable var16) {
         try {
            var2.close();
         } catch (Throwable var15) {
            var16.addSuppressed(var15);
         }

         throw var16;
      }

      var2.close();
   }

   @Override
   class="kw">protected void write(@Nonnull BufferedWriter var1) class="kw">throws IOException {
      HytalePermissionsProvider.State var2 = this.state;
      JsonObject var3 = new JsonObject();
      JsonObject var4 = new JsonObject();

      for (Entry var6 : var2.userPermissions.entrySet()) {
         JsonArray var7 = new JsonArray();
         var6.getValue().forEach(var7::add);
         String var8 = var6.getKey().toString();
         if (!var4.has(var8)) {
            var4.add(var8, new JsonObject());
         }

         var4.getAsJsonObject(var8).add("permissions", var7);
      }

      for (Entry var13 : var2.userGroups.entrySet()) {
         JsonArray var15 = new JsonArray();
         var13.getValue().forEach(var15::add);
         String var17 = var13.getKey().toString();
         if (!var4.has(var17)) {
            var4.add(var17, new JsonObject());
         }

         var4.getAsJsonObject(var17).add("groups", var15);
      }

      if (!var4.isEmpty()) {
         var3.add("users", var4);
      }

      JsonObject var12 = new JsonObject();

      for (Entry var16 : var2.groupData.entrySet()) {
         if (!isUnmodifiedBuiltin(var16.getKey(), var16.getValue())) {
            HytalePermissionsProvider.GroupData var18 = var16.getValue();
            JsonObject var9 = new JsonObject();
            if (var18.parent != null) {
               var9.addProperty("parent", var18.parent);
            }

            JsonArray var10 = new JsonArray();
            var18.permissions.forEach(var10::add);
            var9.add("permissions", var10);
            var12.add(var16.getKey(), var9);
         }
      }

      if (!var12.isEmpty()) {
         var3.add("groups", var12);
      }

      var1.write(GSON.toJson(var3));
   }

   class="kw">private class="kw">static void addValidatedPermission(@Nonnull Set<String> var0, @Nonnull String var1, @Nonnull String var2) {
      if (PermissionValidation.isValidPermissionNode(var1)) {
         var0.add(var1);
      } else {
         ((HytaleLogger.Api)LOGGER.atWarning()).log("Skipping invalid permission node '%s' in group '%s'", var1, var2);
      }
   }

   class="kw">private class="kw">static boolean isUnmodifiedBuiltin(@Nonnull String var0, @Nonnull HytalePermissionsProvider.GroupData var1) {
      HytalePermissionsProvider.GroupData var2 = BUILTIN_GROUPS.get(var0);
      class="kw">return var2 == null ? false : Objects.equals(var2.parent, var1.parent) && var2.permissions.equals(var1.permissions);
   }

   @Override
   class="kw">protected void create(@Nonnull BufferedWriter var1) class="kw">throws IOException {
      JsonWriter var2 = new JsonWriter(var1);

      try {
         var2.beginObject();
         var2.endObject();
      } catch (Throwable var6) {
         try {
            var2.close();
         } catch (Throwable var5) {
            var6.addSuppressed(var5);
         }

         throw var6;
      }

      var2.close();
   }

   class="kw">static {
      Object2ObjectOpenHashMap var0 = new Object2ObjectOpenHashMap();
      var0.put("op", "hytale:Admin");
      var0.put("adventure", "hytale:Adventurer");
      var0.put("adventurer", "hytale:Adventurer");
      var0.put("creative", "hytale:WorldEditor");
      var0.put("class="kw">default", "hytale:Adventurer");
      LEGACY_GROUP_MAPPINGS = Collections.unmodifiableMap(var0);
      LinkedHashMap mx = new LinkedHashMap<>();
      mx.put("hytale:None", new HytalePermissionsProvider.GroupData(null, Set.of()));
      mx.put("hytale:Adventurer", new HytalePermissionsProvider.GroupData("hytale:None", Set.of()));
      mx.put("hytale:Builder", new HytalePermissionsProvider.GroupData("hytale:Adventurer", Set.of()));
      mx.put("hytale:WorldEditor", new HytalePermissionsProvider.GroupData("hytale:Builder", Set.of()));
      mx.put("hytale:ServerEditor", new HytalePermissionsProvider.GroupData("hytale:WorldEditor", Set.of()));
      mx.put("hytale:Admin", new HytalePermissionsProvider.GroupData("hytale:ServerEditor", Set.of("*")));
      BUILTIN_GROUPS = Collections.unmodifiableMap(mx);
   }

   class="kw">private record GroupData(@Nullable String parent, @Nonnull Set<String> permissions) {
      GroupData {
         permissions = Set.copyOf(permissions);
      }
   }

   class="kw">private record State(
      @Nonnull Map<UUID, Set<String>> userPermissions,
      @Nonnull Map<String, HytalePermissionsProvider.GroupData> groupData,
      @Nonnull Map<UUID, Set<String>> userGroups
   ) {
      State {
         userPermissions = Map.copyOf(userPermissions);
         groupData = Map.copyOf(groupData);
         userGroups = Map.copyOf(userGroups);
      }

      @Nonnull
      class="kw">static HytalePermissionsProvider.State frozen(
         @Nonnull Map<UUID, Set<String>> var0, @Nonnull Map<String, HytalePermissionsProvider.GroupData> var1, @Nonnull Map<UUID, Set<String>> var2
      ) {
         class="kw">return new HytalePermissionsProvider.State(copyOfSets(var0), var1, copyOfSets(var2));
      }

      @Nonnull
      HytalePermissionsProvider.State withUserPermissions(@Nonnull UUID var1, @Nonnull Set<String> var2) {
         class="kw">return new HytalePermissionsProvider.State(withEntry(this.userPermissions, var1, var2), this.groupData, this.userGroups);
      }

      @Nonnull
      HytalePermissionsProvider.State withUserGroups(@Nonnull UUID var1, @Nonnull Set<String> var2) {
         class="kw">return new HytalePermissionsProvider.State(this.userPermissions, this.groupData, withEntry(this.userGroups, var1, var2));
      }

      @Nonnull
      class="kw">private class="kw">static <K> Map<K, Set<String>> withEntry(@Nonnull Map<K, Set<String>> var0, @Nonnull K var1, @Nonnull Set<String> var2) {
         Map var3 = new HashMap<>(var0);
         if (var2.isEmpty()) {
            var3.remove(var1);
         } else {
            var3.put(var1, Set.copyOf(var2));
         }

         class="kw">return var3;
      }

      @Nonnull
      class="kw">private class="kw">static <K> Map<K, Set<String>> copyOfSets(@Nonnull Map<K, Set<String>> var0) {
         Map var1 = HashMap.newHashMap(var0.size());

         for (Entry var3 : var0.entrySet()) {
            var1.put(var3.getKey(), Set.copyOf(var3.getValue()));
         }

         class="kw">return var1;
      }
   }
}