CommonAssetRegistry.java

package com.hypixel.hytale.server.core.asset.common;

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

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

   public CommonAssetRegistry() {
   }

   public static int getDuplicateAssetCount() {
      return duplicateAssetCount.get();
   }

   @Nonnull
   public static Map<String, List<PackAsset>> getDuplicatedAssets() {
      Map<String, List<PackAsset>> duplicates = new Object2ObjectOpenHashMap<String, List<PackAsset>>();

      for(Map.Entry<String, List<PackAsset>> entry : assetByHashMap.entrySet()) {
         if (((List)entry.getValue()).size() > 1) {
            duplicates.put((String)entry.getKey(), new ObjectArrayList((Collection)entry.getValue()));
         }
      }

      return duplicates;
   }

   @Nonnull
   public static Collection<List<PackAsset>> getAllAssets() {
      return unmodifiableAssetByNameMapValues;
   }

   public static void clearAllAssets() {
      assetByNameMap.clear();
      assetByHashMap.clear();
   }

   @Nonnull
   public static AddCommonAssetResult addCommonAsset(String pack, @Nonnull CommonAsset asset) {
      AddCommonAssetResult result = new AddCommonAssetResult();
      result.newPackAsset = new PackAsset(pack, asset);
      List<PackAsset> list = (List)assetByNameMap.computeIfAbsent(asset.getName(), (v) -> new CopyOnWriteArrayList());
      boolean added = false;
      boolean addHash = true;

      for(int i = 0; i < list.size(); ++i) {
         PackAsset e = (PackAsset)list.get(i);
         if (e.pack().equals(pack)) {
            result.previousNameAsset = e;
            if (i == list.size() - 1) {
               ((List)assetByHashMap.get(e.asset.getHash())).remove(e);
               assetByHashMap.compute(e.asset.getHash(), (k, v) -> v != null && !v.isEmpty() ? v : null);
            } else {
               addHash = false;
            }

            list.set(i, result.newPackAsset);
            added = true;
            break;
         }
      }

      if (!added) {
         if (!list.isEmpty()) {
            PackAsset e = (PackAsset)list.getLast();
            ((List)assetByHashMap.get(e.asset.getHash())).remove(e);
            assetByHashMap.compute(e.asset.getHash(), (k, v) -> v != null && !v.isEmpty() ? v : null);
            result.previousNameAsset = e;
         }

         list.add(result.newPackAsset);
      }

      if (addHash) {
         List<PackAsset> commonAssets = (List)assetByHashMap.computeIfAbsent(asset.getHash(), (k) -> new CopyOnWriteArrayList());
         if (!commonAssets.isEmpty()) {
            result.previousHashAssets = (PackAsset[])commonAssets.toArray((x$0) -> new PackAsset[x$0]);
         }

         commonAssets.add(result.newPackAsset);
      }

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

      result.activeAsset = (PackAsset)list.getLast();
      return result;
   }

   @Nullable
   public static BooleanObjectPair<PackAsset> removeCommonAssetByName(String pack, String name) {
      name = PatternUtil.replaceBackslashWithForwardSlash(name);
      List<PackAsset> oldAssets = (List)assetByNameMap.get(name);
      if (oldAssets == null) {
         return null;
      } else {
         PackAsset previousCurrent = (PackAsset)oldAssets.getLast();
         oldAssets.removeIf((v) -> v.pack().equals(pack));
         assetByNameMap.compute(name, (k, v) -> v != null && !v.isEmpty() ? v : null);
         if (oldAssets.isEmpty()) {
            removeCommonAssetByHash0(previousCurrent);
            return BooleanObjectPair.<PackAsset>of(false, previousCurrent);
         } else {
            PackAsset newCurrent = (PackAsset)oldAssets.getLast();
            if (newCurrent.equals(previousCurrent)) {
               return null;
            } else {
               removeCommonAssetByHash0(previousCurrent);
               ((List)assetByHashMap.computeIfAbsent(newCurrent.asset.getHash(), (v) -> new CopyOnWriteArrayList())).add(newCurrent);
               return BooleanObjectPair.<PackAsset>of(true, newCurrent);
            }
         }
      }
   }

   @Nonnull
   public static List<CommonAsset> getCommonAssetsStartingWith(String pack, String name) {
      List<CommonAsset> oldAssets = new ObjectArrayList<CommonAsset>();

      for(List<PackAsset> assets : assetByNameMap.values()) {
         for(PackAsset asset : assets) {
            if (asset.asset().getName().startsWith(name) && asset.pack().equals(pack)) {
               oldAssets.add(asset.asset());
            }
         }
      }

      return oldAssets;
   }

   public static boolean hasCommonAsset(String name) {
      return assetByNameMap.containsKey(name);
   }

   public static boolean hasCommonAsset(AssetPack pack, String name) {
      List<PackAsset> packAssets = (List)assetByNameMap.get(name);
      if (packAssets != null) {
         for(PackAsset packAsset : packAssets) {
            if (packAsset.pack.equals(pack.getName())) {
               return true;
            }
         }
      }

      return false;
   }

   @Nullable
   public static CommonAsset getByName(String name) {
      name = PatternUtil.replaceBackslashWithForwardSlash(name);
      List<PackAsset> asset = (List)assetByNameMap.get(name);
      return asset == null ? null : ((PackAsset)asset.getLast()).asset();
   }

   @Nullable
   public static CommonAsset getByHash(@Nonnull String hash) {
      List<PackAsset> assets = (List)assetByHashMap.get(hash.toLowerCase());
      return assets != null && !assets.isEmpty() ? ((PackAsset)assets.getFirst()).asset() : null;
   }

   private static void removeCommonAssetByHash0(@Nonnull PackAsset oldAsset) {
      List<PackAsset> commonAssets = (List)assetByHashMap.get(oldAsset.asset().getHash());
      if (commonAssets != null && commonAssets.remove(oldAsset) && commonAssets.isEmpty()) {
         assetByHashMap.compute(oldAsset.asset().getHash(), (key, assets) -> assets != null && !assets.isEmpty() ? assets : null);
      }

   }

   static {
      unmodifiableAssetByNameMapValues = Collections.unmodifiableCollection(assetByNameMap.values());
   }

   public static class AddCommonAssetResult {
      private PackAsset newPackAsset;
      private PackAsset previousNameAsset;
      private PackAsset activeAsset;
      private PackAsset[] previousHashAssets;
      private int duplicateAssetId;

      public AddCommonAssetResult() {
      }

      public PackAsset getNewPackAsset() {
         return this.newPackAsset;
      }

      public PackAsset getPreviousNameAsset() {
         return this.previousNameAsset;
      }

      public PackAsset getActiveAsset() {
         return this.activeAsset;
      }

      public PackAsset[] getPreviousHashAssets() {
         return this.previousHashAssets;
      }

      public int getDuplicateAssetId() {
         return this.duplicateAssetId;
      }

      @Nonnull
      public String toString() {
         String var10000 = String.valueOf(this.previousNameAsset);
         return "AddCommonAssetResult{previousNameAsset=" + var10000 + ", previousHashAssets=" + Arrays.toString(this.previousHashAssets) + ", duplicateAssetId=" + this.duplicateAssetId + "}";
      }
   }

   public static record PackAsset(String pack, CommonAsset asset) {
      public boolean equals(@Nullable Object o) {
         if (this == o) {
            return true;
         } else if (o != null && this.getClass() == o.getClass()) {
            PackAsset packAsset = (PackAsset)o;
            return !this.pack.equals(packAsset.pack) ? false : this.asset.equals(packAsset.asset);
         } else {
            return false;
         }
      }

      @Nonnull
      public String toString() {
         String var10000 = this.pack;
         return "PackAsset{pack='" + var10000 + "', asset=" + String.valueOf(this.asset) + "}";
      }
   }
}