class="kw">package com.hypixel.hytale.server.core.asset.common;

class="kw">import com.hypixel.hytale.assetstore.AssetPack;
class="kw">import com.hypixel.hytale.common.util.PatternUtil;
class="kw">import it.unimi.dsi.fastutil.booleans.BooleanObjectPair;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collection;
class="kw">import java.util.Collections;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Map;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.CopyOnWriteArrayList;
class="kw">import java.util.concurrent.atomic.AtomicInteger;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class CommonAssetRegistry {
   class="kw">private class="kw">static class="kw">final Map<String, List<CommonAssetRegistry.PackAsset>> assetByNameMap = new ConcurrentHashMap<>();
   class="kw">private class="kw">static class="kw">final Map<String, List<CommonAssetRegistry.PackAsset>> assetByHashMap = new ConcurrentHashMap<>();
   class="kw">private class="kw">static class="kw">final AtomicInteger duplicateAssetCount = new AtomicInteger();
   class="kw">private class="kw">static class="kw">final Collection<List<CommonAssetRegistry.PackAsset>> unmodifiableAssetByNameMapValues = Collections.unmodifiableCollection(
      assetByNameMap.values()
   );

   class="kw">public CommonAssetRegistry() {
   }

   class="kw">public class="kw">static int getDuplicateAssetCount() {
      class="kw">return duplicateAssetCount.get();
   }

   @Nonnull
   class="kw">public class="kw">static Map<String, List<CommonAssetRegistry.PackAsset>> getDuplicatedAssets() {
      Map var0 = new Object2ObjectOpenHashMap();

      for (Entry var2 : assetByHashMap.entrySet()) {
         if (var2.getValue().size() > 1) {
            var0.put(var2.getKey(), new ObjectArrayList(var2.getValue()));
         }
      }

      class="kw">return var0;
   }

   @Nonnull
   class="kw">public class="kw">static Collection<List<CommonAssetRegistry.PackAsset>> getAllAssets() {
      class="kw">return unmodifiableAssetByNameMapValues;
   }

   class="kw">public class="kw">static void clearAllAssets() {
      assetByNameMap.clear();
      assetByHashMap.clear();
   }

   @Nonnull
   class="kw">public class="kw">static CommonAssetRegistry.AddCommonAssetResult addCommonAsset(String var0, @Nonnull CommonAsset var1) {
      CommonAssetRegistry.AddCommonAssetResult var2 = new CommonAssetRegistry.AddCommonAssetResult();
      var2.newPackAsset = new CommonAssetRegistry.PackAsset(var0, var1);
      List var3 = assetByNameMap.computeIfAbsent(var1.getName(), var0x -> new CopyOnWriteArrayList<>());
      boolean var4 = false;
      boolean var5 = true;

      for (int var6 = 0; var6 < var3.size(); var6++) {
         CommonAssetRegistry.PackAsset var7 = var3.get(var6);
         if (var7.pack().equals(var0)) {
            var2.previousNameAsset = var7;
            if (var6 == var3.size() - 1) {
               assetByHashMap.get(var7.asset.getHash()).remove(var7);
               assetByHashMap.compute(var7.asset.getHash(), (var0x, var1x) -> var1x != null && !var1x.isEmpty() ? var1x : null);
            } else {
               var5 = false;
            }

            var3.set(var6, var2.newPackAsset);
            var4 = true;
            break;
         }
      }

      if (!var4) {
         if (!var3.isEmpty()) {
            CommonAssetRegistry.PackAsset var8 = var3.getLast();
            assetByHashMap.get(var8.asset.getHash()).remove(var8);
            assetByHashMap.compute(var8.asset.getHash(), (var0x, var1x) -> var1x != null && !var1x.isEmpty() ? var1x : null);
            var2.previousNameAsset = var8;
         }

         var3.add(var2.newPackAsset);
      }

      if (var5) {
         List var9 = assetByHashMap.computeIfAbsent(var1.getHash(), var0x -> new CopyOnWriteArrayList<>());
         if (!var9.isEmpty()) {
            var2.previousHashAssets = var9.toArray(CommonAssetRegistry.PackAsset[]::new);
         }

         var9.add(var2.newPackAsset);
      }

      if (var2.previousHashAssets != null || var2.previousNameAsset != null) {
         var2.duplicateAssetId = duplicateAssetCount.getAndIncrement();
      }

      var2.activeAsset = var3.getLast();
      class="kw">return var2;
   }

   @Nullable
   class="kw">public class="kw">static BooleanObjectPair<CommonAssetRegistry.PackAsset> removeCommonAssetByName(String var0, String var1) {
      var1 = PatternUtil.replaceBackslashWithForwardSlash(var1);
      List var2 = assetByNameMap.get(var1);
      if (var2 == null) {
         class="kw">return null;
      }

      CommonAssetRegistry.PackAsset var3 = var2.getLast();
      var2.removeIf(var1x -> var1x.pack().equals(var0));
      assetByNameMap.compute(var1, (var0x, var1x) -> var1x != null && !var1x.isEmpty() ? var1x : null);
      if (var2.isEmpty()) {
         removeCommonAssetByHash0(var3);
         class="kw">return BooleanObjectPair.of(false, var3);
      }

      CommonAssetRegistry.PackAsset var4 = var2.getLast();
      if (var4.equals(var3)) {
         class="kw">return null;
      }

      removeCommonAssetByHash0(var3);
      assetByHashMap.computeIfAbsent(var4.asset.getHash(), var0x -> new CopyOnWriteArrayList<>()).add(var4);
      class="kw">return BooleanObjectPair.of(true, var4);
   }

   @Nonnull
   class="kw">public class="kw">static List<CommonAsset> getCommonAssetsStartingWith(String var0, String var1) {
      List var2 = new ObjectArrayList();

      for (List var4 : assetByNameMap.values()) {
         for (CommonAssetRegistry.PackAsset var6 : var4) {
            if (var6.asset().getName().startsWith(var1) && var6.pack().equals(var0)) {
               var2.add(var6.asset());
            }
         }
      }

      class="kw">return var2;
   }

   class="kw">public class="kw">static boolean hasCommonAsset(String var0) {
      class="kw">return assetByNameMap.containsKey(var0);
   }

   class="kw">public class="kw">static boolean hasCommonAsset(AssetPack var0, String var1) {
      List var2 = assetByNameMap.get(var1);
      if (var2 != null) {
         for (CommonAssetRegistry.PackAsset var4 : var2) {
            if (var4.pack.equals(var0.getName())) {
               class="kw">return true;
            }
         }
      }

      class="kw">return false;
   }

   @Nullable
   class="kw">public class="kw">static CommonAsset getByName(String var0) {
      var0 = PatternUtil.replaceBackslashWithForwardSlash(var0);
      List var1 = assetByNameMap.get(var0);
      class="kw">return var1 == null ? null : var1.getLast().asset();
   }

   @Nullable
   class="kw">public class="kw">static CommonAsset getByHash(@Nonnull String var0) {
      List var1 = assetByHashMap.get(var0.toLowerCase(Locale.ROOT));
      class="kw">return var1 != null && !var1.isEmpty() ? var1.getFirst().asset() : null;
   }

   class="kw">private class="kw">static void removeCommonAssetByHash0(@Nonnull CommonAssetRegistry.PackAsset var0) {
      List var1 = assetByHashMap.get(var0.asset().getHash());
      if (var1 != null && var1.remove(var0) && var1.isEmpty()) {
         assetByHashMap.compute(var0.asset().getHash(), (var0x, var1x) -> var1x != null && !var1x.isEmpty() ? var1x : null);
      }
   }

   class="kw">public class="kw">static class AddCommonAssetResult {
      class="kw">private CommonAssetRegistry.PackAsset newPackAsset;
      class="kw">private CommonAssetRegistry.PackAsset previousNameAsset;
      class="kw">private CommonAssetRegistry.PackAsset activeAsset;
      class="kw">private CommonAssetRegistry.PackAsset[] previousHashAssets;
      class="kw">private int duplicateAssetId;

      class="kw">public AddCommonAssetResult() {
      }

      class="kw">public CommonAssetRegistry.PackAsset getNewPackAsset() {
         class="kw">return this.newPackAsset;
      }

      class="kw">public CommonAssetRegistry.PackAsset getPreviousNameAsset() {
         class="kw">return this.previousNameAsset;
      }

      class="kw">public CommonAssetRegistry.PackAsset getActiveAsset() {
         class="kw">return this.activeAsset;
      }

      class="kw">public CommonAssetRegistry.PackAsset[] getPreviousHashAssets() {
         class="kw">return this.previousHashAssets;
      }

      class="kw">public int getDuplicateAssetId() {
         class="kw">return this.duplicateAssetId;
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "AddCommonAssetResult{previousNameAsset="
            + this.previousNameAsset
            + ", previousHashAssets="
            + Arrays.toString(this.previousHashAssets)
            + ", duplicateAssetId="
            + this.duplicateAssetId
            + "}";
      }
   }

   class="kw">public record PackAsset(String pack, CommonAsset asset) {
      class="kw">public PackAsset {
      }

      @Override
      class="kw">public boolean equals(@Nullable Object var1) {
         if (this == var1) {
            class="kw">return true;
         } else if (var1 != null && this.getClass() == var1.getClass()) {
            CommonAssetRegistry.PackAsset var2 = (CommonAssetRegistry.PackAsset)var1;
            class="kw">return !this.pack.equals(var2.pack) ? false : this.asset.equals(var2.asset);
         } else {
            class="kw">return false;
         }
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "PackAsset{pack='" + this.pack + "', asset=" + this.asset + "}";
      }
   }
}