class="kw">package com.hypixel.hytale.assetstore.map;

class="kw">import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
class="kw">import com.hypixel.hytale.assetstore.AssetExtraInfo;
class="kw">import com.hypixel.hytale.assetstore.AssetMap;
class="kw">import com.hypixel.hytale.assetstore.JsonAsset;
class="kw">import com.hypixel.hytale.assetstore.codec.AssetCodec;
class="kw">import it.unimi.dsi.fastutil.ints.IntIterator;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import it.unimi.dsi.fastutil.ints.IntSets;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenCustomHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectSet;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectSets;
class="kw">import java.nio.file.Path;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.HashSet;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.locks.StampedLock;
class="kw">import java.util.stream.Collectors;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class DefaultAssetMap<K, T class="kw">extends JsonAsset<K>> class="kw">extends AssetMap<K, T> {
   class="kw">public class="kw">static class="kw">final DefaultAssetMap.AssetRef[] EMPTY_PAIR_ARRAY = new DefaultAssetMap.AssetRef[0];
   class="kw">public class="kw">static class="kw">final String DEFAULT_PACK_KEY = "Hytale:Hytale";
   class="kw">protected class="kw">final StampedLock assetMapLock = new StampedLock();
   @Nonnull
   class="kw">protected class="kw">final Map<K, T> assetMap;
   class="kw">protected class="kw">final Map<K, DefaultAssetMap.AssetRef<T>[]> assetChainMap;
   class="kw">protected class="kw">final Map<String, ObjectSet<K>> packAssetKeys = new ConcurrentHashMap<>();
   class="kw">protected class="kw">final Map<Path, ObjectSet<K>> pathToKeyMap = new ConcurrentHashMap<>();
   class="kw">protected class="kw">final Map<K, ObjectSet<K>> assetChildren;
   class="kw">protected class="kw">final Int2ObjectConcurrentHashMap<Set<K>> tagStorage = new Int2ObjectConcurrentHashMap<>();
   class="kw">protected class="kw">final Int2ObjectConcurrentHashMap<Set<K>> unmodifiableTagStorage = new Int2ObjectConcurrentHashMap<>();
   class="kw">protected class="kw">final IntSet unmodifiableTagKeys = IntSets.unmodifiable(this.tagStorage.keySet());

   class="kw">public DefaultAssetMap() {
      this.assetMap = new Object2ObjectOpenCustomHashMap(CaseInsensitiveHashStrategy.getInstance());
      this.assetChainMap = new Object2ObjectOpenCustomHashMap(CaseInsensitiveHashStrategy.getInstance());
      this.assetChildren = new Object2ObjectOpenCustomHashMap(CaseInsensitiveHashStrategy.getInstance());
   }

   class="kw">public DefaultAssetMap(@Nonnull Map<K, T> var1) {
      this.assetMap = var1;
      this.assetChainMap = new Object2ObjectOpenCustomHashMap(CaseInsensitiveHashStrategy.getInstance());
      this.assetChildren = new Object2ObjectOpenCustomHashMap(CaseInsensitiveHashStrategy.getInstance());
   }

   @Nullable
   @Override
   class="kw">public T getAsset(K var1) {
      long var2 = this.assetMapLock.tryOptimisticRead();
      JsonAsset var4 = this.assetMap.get(var1);
      if (this.assetMapLock.validate(var2)) {
         class="kw">return var4;
      }

      var2 = this.assetMapLock.readLock();

      try {
         class="kw">return this.assetMap.get(var1);
      } class="kw">finally {
         this.assetMapLock.unlockRead(var2);
      }
   }

   @Nullable
   @Override
   class="kw">public T getAsset(@Nonnull String var1, K var2) {
      long var3 = this.assetMapLock.tryOptimisticRead();
      JsonAsset var5 = this.getAssetForPack0(var1, var2);
      if (this.assetMapLock.validate(var3)) {
         class="kw">return var5;
      }

      var3 = this.assetMapLock.readLock();

      try {
         class="kw">return this.getAssetForPack0(var1, var2);
      } class="kw">finally {
         this.assetMapLock.unlockRead(var3);
      }
   }

   class="kw">private T getAssetForPack0(@Nonnull String var1, K var2) {
      DefaultAssetMap.AssetRef[] var3 = this.assetChainMap.get(var2);
      if (var3 == null) {
         class="kw">return null;
      }

      for (int var4 = 0; var4 < var3.length; var4++) {
         DefaultAssetMap.AssetRef var5 = var3[var4];
         if (Objects.equals(var5.pack, var1)) {
            if (var4 == 0) {
               class="kw">return null;
            }

            class="kw">return var3[var4 - 1].value;
         }
      }

      class="kw">return this.assetMap.get(var2);
   }

   @Nullable
   @Override
   class="kw">public Path getPath(K var1) {
      long var2 = this.assetMapLock.tryOptimisticRead();
      Path var4 = this.getPath0(var1);
      if (this.assetMapLock.validate(var2)) {
         class="kw">return var4;
      }

      var2 = this.assetMapLock.readLock();

      try {
         class="kw">return this.getPath0(var1);
      } class="kw">finally {
         this.assetMapLock.unlockRead(var2);
      }
   }

   @Nullable
   @Override
   class="kw">public String getAssetPack(K var1) {
      long var2 = this.assetMapLock.tryOptimisticRead();
      String var4 = this.getAssetPack0(var1);
      if (this.assetMapLock.validate(var2)) {
         class="kw">return var4;
      }

      var2 = this.assetMapLock.readLock();

      try {
         class="kw">return this.getAssetPack0(var1);
      } class="kw">finally {
         this.assetMapLock.unlockRead(var2);
      }
   }

   @Nullable
   class="kw">private Path getPath0(K var1) {
      DefaultAssetMap.AssetRef var2 = this.getAssetRef(var1);
      class="kw">return var2 != null ? var2.path : null;
   }

   @Nullable
   class="kw">private String getAssetPack0(K var1) {
      DefaultAssetMap.AssetRef var2 = this.getAssetRef(var1);
      class="kw">return var2 != null ? var2.pack : null;
   }

   @Nullable
   class="kw">private DefaultAssetMap.AssetRef<T> getAssetRef(K var1) {
      DefaultAssetMap.AssetRef[] var2 = this.assetChainMap.get(var1);
      class="kw">return var2 == null ? null : var2[var2.length - 1];
   }

   @Override
   class="kw">public Set<K> getKeys(@Nonnull Path var1) {
      ObjectSet var2 = this.pathToKeyMap.get(var1);
      class="kw">return var2 == null ? ObjectSets.emptySet() : ObjectSets.unmodifiable(var2);
   }

   @Override
   class="kw">public Set<K> getChildren(K var1) {
      long var2 = this.assetMapLock.tryOptimisticRead();
      ObjectSet var4 = this.assetChildren.get(var1);
      Set var5 = var4 == null ? ObjectSets.emptySet() : ObjectSets.unmodifiable(var4);
      if (this.assetMapLock.validate(var2)) {
         class="kw">return var5;
      }

      var2 = this.assetMapLock.readLock();

      try {
         var4 = this.assetChildren.get(var1);
         class="kw">return var4 == null ? ObjectSets.emptySet() : ObjectSets.unmodifiable(var4);
      } class="kw">finally {
         this.assetMapLock.unlockRead(var2);
      }
   }

   @Override
   class="kw">public int getAssetCount() {
      class="kw">return this.assetMap.size();
   }

   @Nonnull
   @Override
   class="kw">public Map<K, T> getAssetMap() {
      class="kw">return Collections.unmodifiableMap(this.assetMap);
   }

   @Nonnull
   @Override
   class="kw">public Map<K, Path> getPathMap(@Nonnull String var1) {
      long var2 = this.assetMapLock.readLock();

      try {
         class="kw">return this.assetChainMap
            .entrySet()
            .stream()
            .map(var1x -> Map.entry(var1x.getKey(), Arrays.stream(var1x.getValue()).filter(var1xx -> Objects.equals(var1xx.pack, var1)).findFirst()))
            .filter(var0 -> var0.getValue().isPresent())
            .filter(var0 -> var0.getValue().get().path != null)
            .collect(Collectors.toMap(Entry::getKey, var0 -> var0.getValue().get().path));
      } class="kw">finally {
         this.assetMapLock.unlockRead(var2);
      }
   }

   @Override
   class="kw">public Set<K> getKeysForTag(int var1) {
      class="kw">return this.unmodifiableTagStorage.getOrDefault(var1, ObjectSets.emptySet());
   }

   @Nonnull
   @Override
   class="kw">public IntSet getTagIndexes() {
      class="kw">return this.unmodifiableTagKeys;
   }

   @Override
   class="kw">public int getTagCount() {
      class="kw">return this.tagStorage.size();
   }

   @Override
   class="kw">protected void clear() {
      long var1 = this.assetMapLock.writeLock();

      try {
         this.assetChildren.clear();
         this.assetChainMap.clear();
         this.pathToKeyMap.clear();
         this.assetMap.clear();
         this.tagStorage.clear();
         this.unmodifiableTagStorage.clear();
      } class="kw">finally {
         this.assetMapLock.unlockWrite(var1);
      }
   }

   @Override
   class="kw">protected void putAll(
      @Nonnull String var1, @Nonnull AssetCodec<K, T> var2, @Nonnull Map<K, T> var3, @Nonnull Map<K, Path> var4, @Nonnull Map<K, Set<K>> var5
   ) {
      long var6 = this.assetMapLock.writeLock();

      try {
         for (Entry var9 : var5.entrySet()) {
            this.assetChildren.computeIfAbsent(var9.getKey(), var0 -> new ObjectOpenHashSet(3)).addAll(var9.getValue());
         }

         for (Entry var22 : var4.entrySet()) {
            this.pathToKeyMap.computeIfAbsent(var22.getValue(), var0 -> new ObjectOpenHashSet(1)).add(var22.getKey());
         }

         for (Entry var23 : var3.entrySet()) {
            Object var10 = var23.getKey();
            this.packAssetKeys.computeIfAbsent(var1, var0 -> new ObjectOpenHashSet()).add(var10);
            DefaultAssetMap.AssetRef[] var11 = this.assetChainMap.get(var10);
            if (var11 == null) {
               var11 = EMPTY_PAIR_ARRAY;
            }

            boolean var12 = false;
            DefaultAssetMap.AssetRef[] var13 = var11;
            int var14 = var13.length;
            int var15 = 0;

            while (true) {
               if (var15 < var14) {
                  DefaultAssetMap.AssetRef var16 = var13[var15];
                  if (!Objects.equals(var16.pack, var1)) {
                     var15++;
                     class="kw">continue;
                  }

                  var16.value = var23.getValue();
                  var12 = true;
               }

               if (!var12) {
                  var11 = Arrays.copyOf(var11, var11.length + 1);
                  var11[var11.length - 1] = new DefaultAssetMap.AssetRef<>(var1, var4.get(var23.getKey()), var23.getValue());
                  this.assetChainMap.put(var10, var11);
               }

               JsonAsset var24 = var11[var11.length - 1].value;
               this.assetMap.put(var10, var24);
               break;
            }
         }
      } class="kw">finally {
         this.assetMapLock.unlockWrite(var6);
      }

      this.putAssetTags(var2, var3);
   }

   class="kw">protected void putAssetTags(@Nonnull AssetCodec<K, T> var1, @Nonnull Map<K, T> var2) {
      for (Entry var4 : var2.entrySet()) {
         AssetExtraInfo.Data var5 = var1.getData(var4.getValue());
         if (var5 != null) {
            Object var6 = var4.getKey();
            IntIterator var7 = var5.getExpandedTagIndexes().iterator();

            while (var7.hasNext()) {
               int var8 = var7.nextInt();
               this.putAssetTag(var6, var8);
            }
         }
      }
   }

   class="kw">protected void putAssetTag(K var1, int var2) {
      this.tagStorage.computeIfAbsent(var2, var1x -> {
         ObjectOpenHashSet var2 = new ObjectOpenHashSet(3);
         this.unmodifiableTagStorage.put(var1x, ObjectSets.unmodifiable(var2));
         class="kw">return var2;
      }).add(var1);
   }

   @Override
   class="kw">public Set<K> getKeysForPack(@Nonnull String var1) {
      class="kw">return (Set<K>)this.packAssetKeys.get(var1);
   }

   @Override
   class="kw">protected Set<K> remove(@Nonnull Set<K> var1) {
      long var2 = this.assetMapLock.writeLock();

      try {
         Set var4 = new HashSet<>();

         for (Object var6 : var1) {
            DefaultAssetMap.AssetRef[] var7 = this.assetChainMap.remove(var6);
            if (var7 != null) {
               DefaultAssetMap.AssetRef var8 = var7[var7.length - 1];
               if (var8.path != null) {
                  this.pathToKeyMap.computeIfPresent(var8.path, (var1x, var2x) -> {
                     var2x.remove(var6);
                     class="kw">return var2x.isEmpty() ? null : var2x;
                  });
               }

               this.assetMap.remove(var6);

               for (DefaultAssetMap.AssetRef var12 : var7) {
                  this.packAssetKeys.get(Objects.requireNonNullElse(var12.pack, "Hytale:Hytale")).remove(var6);
               }

               for (ObjectSet var18 : this.assetChildren.values()) {
                  var18.remove(var6);
               }

               ObjectSet var17 = this.assetChildren.remove(var6);
               if (var17 != null) {
                  var4.addAll(var17);
               }
            }
         }

         this.tagStorage.forEach((var0, var1x, var2x) -> var1x.removeAll(var2x), var1);
         var4.removeAll(var1);
         class="kw">return var4;
      } class="kw">finally {
         this.assetMapLock.unlockWrite(var2);
      }
   }

   @Override
   class="kw">protected Set<K> remove(@Nonnull String var1, @Nonnull Set<K> var2, @Nonnull List<Entry<String, Object>> var3) {
      long var4 = this.assetMapLock.writeLock();

      try {
         Set var6 = new HashSet<>();
         ObjectSet var7 = this.packAssetKeys.get(Objects.requireNonNullElse(var1, "Hytale:Hytale"));
         if (var7 == null) {
            class="kw">return Collections.emptySet();
         }

         Iterator var8 = var2.iterator();

         while (var8.hasNext()) {
            Object var9 = var8.next();
            var7.remove(var9);
            DefaultAssetMap.AssetRef[] var10 = this.assetChainMap.remove(var9);
            if (var10 != null) {
               if (var10.length == 1) {
                  DefaultAssetMap.AssetRef var18 = var10[0];
                  if (!Objects.equals(var18.pack, var1)) {
                     var8.remove();
                     this.assetChainMap.put(var9, var10);
                  } else {
                     if (var18.path != null) {
                        this.pathToKeyMap.computeIfPresent(var18.path, (var1x, var2x) -> {
                           var2x.remove(var9);
                           class="kw">return var2x.isEmpty() ? null : var2x;
                        });
                     }

                     this.assetMap.remove(var9);

                     for (ObjectSet var22 : this.assetChildren.values()) {
                        var22.remove(var9);
                     }

                     ObjectSet var20 = this.assetChildren.remove(var9);
                     if (var20 != null) {
                        var6.addAll(var20);
                     }
                  }
               } else {
                  var8.remove();
                  DefaultAssetMap.AssetRef[] var11 = new DefaultAssetMap.AssetRef[var10.length - 1];
                  int var12 = 0;

                  for (int var13 = 0; var13 < var10.length; var13++) {
                     DefaultAssetMap.AssetRef var14 = var10[var13];
                     if (Objects.equals(var14.pack, var1)) {
                        if (var14.path != null) {
                           this.pathToKeyMap.computeIfPresent(var14.path, (var1x, var2x) -> {
                              var2x.remove(var9);
                              class="kw">return var2x.isEmpty() ? null : var2x;
                           });
                        }
                     } else {
                        var11[var12++] = var14;
                        if (var14.path != null) {
                           var3.add(Map.entry(var14.pack, var14.path));
                        } else {
                           var3.add(Map.entry(var14.pack, var14.value));
                        }
                     }
                  }

                  this.assetChainMap.put(var9, var11);
                  DefaultAssetMap.AssetRef var21 = var11[var11.length - 1];
                  this.assetMap.put(var9, var21.value);
                  if (var21.path != null) {
                     this.pathToKeyMap.computeIfAbsent(var21.path, var0 -> new ObjectOpenHashSet(1)).add(var9);
                  }
               }
            }
         }

         this.tagStorage.forEach((var0, var1x, var2x) -> var1x.removeAll(var2x), var2);
         var6.removeAll(var2);
         class="kw">return var6;
      } class="kw">finally {
         this.assetMapLock.unlockWrite(var4);
      }
   }

   class="kw">protected class="kw">static class AssetRef<T> {
      class="kw">protected class="kw">final String pack;
      class="kw">protected class="kw">final Path path;
      class="kw">protected T value;

      class="kw">protected AssetRef(String var1, Path var2, T var3) {
         this.pack = var1;
         this.path = var2;
         this.value = var3;
      }
   }
}