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.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.common.util.FormatUtil;
class="kw">import com.hypixel.hytale.common.util.PathUtil;
class="kw">import com.hypixel.hytale.common.util.PatternUtil;
class="kw">import com.hypixel.hytale.event.IEventDispatcher;
class="kw">import com.hypixel.hytale.function.supplier.CachedSupplier;
class="kw">import com.hypixel.hytale.function.supplier.SupplierUtil;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.logger.sentry.SkipSentryException;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.protocol.Asset;
class="kw">import com.hypixel.hytale.protocol.ToClientPacket;
class="kw">import com.hypixel.hytale.protocol.packets.interface_.Notification;
class="kw">import com.hypixel.hytale.protocol.packets.interface_.NotificationStyle;
class="kw">import com.hypixel.hytale.protocol.packets.setup.AssetFinalize;
class="kw">import com.hypixel.hytale.protocol.packets.setup.AssetInitialize;
class="kw">import com.hypixel.hytale.protocol.packets.setup.AssetPart;
class="kw">import com.hypixel.hytale.protocol.packets.setup.RemoveAssets;
class="kw">import com.hypixel.hytale.protocol.packets.setup.RequestCommonAssetsRebuild;
class="kw">import com.hypixel.hytale.protocol.packets.setup.WorldLoadProgress;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.asset.AssetModule;
class="kw">import com.hypixel.hytale.server.core.asset.AssetPackRegisterEvent;
class="kw">import com.hypixel.hytale.server.core.asset.AssetPackUnregisterEvent;
class="kw">import com.hypixel.hytale.server.core.asset.LoadAssetEvent;
class="kw">import com.hypixel.hytale.server.core.asset.common.asset.FileCommonAsset;
class="kw">import com.hypixel.hytale.server.core.asset.common.events.CommonAssetMonitorEvent;
class="kw">import com.hypixel.hytale.server.core.asset.common.events.SendCommonAssetsEvent;
class="kw">import com.hypixel.hytale.server.core.asset.monitor.AssetMonitor;
class="kw">import com.hypixel.hytale.server.core.asset.monitor.AssetMonitorHandler;
class="kw">import com.hypixel.hytale.server.core.asset.monitor.EventKind;
class="kw">import com.hypixel.hytale.server.core.io.PacketHandler;
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.Universe;
class="kw">import com.hypixel.hytale.server.core.util.NotificationUtil;
class="kw">import com.hypixel.hytale.server.core.util.io.FileUtil;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import it.unimi.dsi.fastutil.booleans.BooleanObjectPair;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.io.BufferedReader;
class="kw">import java.io.IOException;
class="kw">import java.nio.file.FileVisitResult;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.InvalidPathException;
class="kw">import java.nio.file.NoSuchFileException;
class="kw">import java.nio.file.Path;
class="kw">import java.nio.file.SimpleFileVisitor;
class="kw">import java.nio.file.attribute.BasicFileAttributes;
class="kw">import java.time.Instant;
class="kw">import java.time.temporal.ChronoUnit;
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.CompletableFuture;
class="kw">import java.util.concurrent.atomic.AtomicInteger;
class="kw">import java.util.logging.Level;
class="kw">import java.util.stream.Stream;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class CommonAssetModule class="kw">extends JavaPlugin {
   class="kw">public class="kw">static class="kw">final PluginManifest MANIFEST = PluginManifest.corePlugin(CommonAssetModule.class).depends(AssetModule.class).build();
   class="kw">private class="kw">static CommonAssetModule instance;
   class="kw">public class="kw">static class="kw">final Set<Path> IGNORED_FILES = Set.of(Path.of(".DS_Store"), Path.of("Thumbs.db"));
   class="kw">public class="kw">static class="kw">final Instant TICK_TIMESTAMP_ORIGIN = Instant.parse("0001-01-01T00:00:00Z");
   class="kw">public class="kw">static class="kw">final String ASSET_INDEX_VERSION_IDENTIFIER = "VERSION=";
   class="kw">public class="kw">static class="kw">final int ASSET_INDEX_HASHES_VERSION = 0;
   class="kw">public class="kw">static class="kw">final int ASSET_INDEX_CACHE_VERSION = 1;
   class="kw">public class="kw">static class="kw">final int MAX_FRAME = 2621440;
   class="kw">private class="kw">final CachedSupplier<Asset[]> assets = SupplierUtil.cache(
      () -> CommonAssetRegistry.getAllAssets()
         .stream()
         .map(List::getLast)
         .map(CommonAssetRegistry.PackAsset::asset)
         .map(CommonAsset::toPacket)
         .toArray(Asset[]::new)
   );

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

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

   @Override
   class="kw">protected void setup() {
      this.getEventRegistry().register(SendCommonAssetsEvent.class, this::onSendCommonAssets);
      this.getEventRegistry().register((short)-32, LoadAssetEvent.class, var1 -> {
         for (AssetPack var3 : AssetModule.get().getAssetPacks()) {
            this.loadCommonAssets(var3, var1.getBootStart());
         }
      });
      this.getEventRegistry().register((short)-32, AssetPackRegisterEvent.class, var1 -> this.loadCommonAssets(var1.getAssetPack(), System.nanoTime()));
      this.getEventRegistry().register(AssetPackUnregisterEvent.class, var1 -> this.removeCommonAssets(var1.getAssetPack()));
   }

   class="kw">private void removeCommonAssets(@Nonnull AssetPack var1) {
      this.unregisterAssetMonitor(var1);
      List var2 = new ObjectArrayList();
      List var3 = new ObjectArrayList();

      for (List var6 : CommonAssetRegistry.getAllAssets()) {
         for (CommonAssetRegistry.PackAsset var8 : var6) {
            if (var8.pack().equals(var1.getName())) {
               BooleanObjectPair var9 = CommonAssetRegistry.removeCommonAssetByName(var8.pack(), var8.asset().getName());
               if (var9 != null) {
                  if (var9.firstBoolean()) {
                     var3.add(((CommonAssetRegistry.PackAsset)var9.second()).asset());
                  } else {
                     var2.add((CommonAssetRegistry.PackAsset)var9.second());
                  }
               }

               this.assets.invalidate();
            }
         }
      }

      this.sendRemoveAssets(var2, false);
      this.sendAssets(var3, false);
      Universe.get().broadcastPacketNoCache(new RequestCommonAssetsRebuild());
   }

   class="kw">public void loadCommonAssets(@Nonnull AssetPack var1, long var2) {
      Path var4 = var1.getRoot();
      HytaleLogger.getLogger().at(Level.INFO).log("Loading common assets from: %s", var4);
      long var5 = System.nanoTime();
      if (this.readCommonAssetsIndexHashes(var1)) {
         int var11 = CommonAssetRegistry.getDuplicateAssetCount();
         if (var11 > 0) {
            this.getLogger().at(Level.WARNING).log("Duplicated Asset Count: %s", var11);
         }

         HytaleLogger.getLogger()
            .at(Level.INFO)
            .log(
               "Loading common assets phase completed! Boot time %s, Took %s",
               FormatUtil.nanosToString(System.nanoTime() - var2),
               FormatUtil.nanosToString(System.nanoTime() - var5)
            );
      } else {
         Path var7 = var1.getRoot().resolve("Common");
         AssetMonitor var8 = AssetModule.get().getAssetMonitor();
         if (var8 != null && !var1.isImmutable() && Files.isDirectory(var7)) {
            var8.monitorDirectoryFiles(var7, new CommonAssetModule.CommonAssetMonitorHandler(var1, var7));
         }

         this.readCommonAssetsIndexCache(var1);

         try {
            this.walkFileTree(var1);
         } catch (IOException var10) {
            throw SneakyThrow.sneakyThrow(var10);
         }

         int var9 = CommonAssetRegistry.getDuplicateAssetCount();
         if (var9 > 0) {
            this.getLogger().at(Level.WARNING).log("Duplicated Asset Count: %s", var9);
         }

         HytaleLogger.getLogger()
            .at(Level.INFO)
            .log(
               "Loading common assets phase completed! Boot time %s, Took %s",
               FormatUtil.nanosToString(System.nanoTime() - var2),
               FormatUtil.nanosToString(System.nanoTime() - var5)
            );
         Universe.get().broadcastPacketNoCache(new RequestCommonAssetsRebuild());
      }
   }

   class="kw">public <T class="kw">extends CommonAsset> void addCommonAsset(String var1, @Nonnull T var2) {
      this.addCommonAsset(var1, var2, true);
   }

   class="kw">public <T class="kw">extends CommonAsset> void addCommonAsset(String var1, @Nonnull T var2, boolean var3) {
      CommonAssetRegistry.AddCommonAssetResult var4 = CommonAssetRegistry.addCommonAsset(var1, var2);
      CommonAssetRegistry.PackAsset var5 = var4.getNewPackAsset();
      CommonAssetRegistry.PackAsset var6 = var4.getPreviousNameAsset();
      if (var6 != null && var6.asset().getHash().equals(var5.asset().getHash())) {
         if (var3) {
            this.getLogger().at(Level.INFO).log("Didn't change: %s", var2.getName());
         }
      } else {
         if (var6 == null) {
            if (var3) {
               this.getLogger().at(Level.INFO).log("Created: %s", var5);
            }
         } else if (var3) {
            this.getLogger().at(Level.INFO).log("Reloaded: %s - Old Hash: %s", var5, var6.asset().getHash());
         }

         String var7 = var6 == null ? "server.general.assetstore.reloadAssets" : "server.general.assetstore.reloadAssets";
         String var8 = var6 == null ? "Icons/AssetNotifications/IconCheckmark.png" : "Icons/AssetNotifications/AssetReloaded.png";
         String var9 = var6 == null ? "#06EE92" : "#A7AfA7";
         NotificationUtil.sendNotificationToUniverse(
            Message.translation(var7).color(var9).param("class", "Common"),
            Message.raw(var5.pack() + ":" + var5.asset().getName()),
            var8,
            NotificationStyle.Success
         );
         if (var4.getActiveAsset().equals(var5)) {
            this.assets.invalidate();
            BlockyAnimationCache.invalidate(var5.asset().getName());
            if (Universe.get().getPlayerCount() > 0) {
               this.sendAsset(var5.asset(), false);
            }
         }
      }
   }

   @Nullable
   class="kw">public Asset[] getRequiredAssets() {
      class="kw">return this.assets.get();
   }

   class="kw">private boolean readCommonAssetsIndexHashes(@Nonnull AssetPack var1) {
      Path var2 = var1.getRoot();
      Path var3 = var2.resolve("CommonAssetsIndex.hashes");
      if (!Files.isRegularFile(var3)) {
         class="kw">return false;
      }

      Path var4 = this.resolveCommonAssetsRoot(var1, "CommonAssetsIndex.hashes");
      if (var4 == null) {
         class="kw">return true;
      }

      long var5 = System.nanoTime();
      int var7 = 0;

      try (BufferedReader var8 = Files.newBufferedReader(var3)) {
         int var9 = 0;
         int var10 = 0;

         while (true) {
            String var11 = var8.readLine();
            if (var11 == null) {
               break;
            }

            if (var11.startsWith("VERSION=")) {
               var9 = Integer.parseInt(var11.substring("VERSION=".length()));
               this.getLogger().at(Level.FINEST).log("Version set to %d from CommonAssetsIndex.hashes:L%d '%s'", var9, var10, var11);
               if (var9 > 0) {
                  throw new IllegalArgumentException(String.format("Unsupported version %d in CommonAssetsIndex.hashes %d > %d", var9, var9, 0));
               }
            } else {
               String[] var12 = var11.split(" ", 2);
               if (var12.length != 2) {
                  this.getLogger().at(Level.WARNING).log("Corrupt line in CommonAssetsIndex.hashes:L%d '%s'", var10, var11);
               } else {
                  String var13 = var12[0];
                  if (!CommonAsset.HASH_PATTERN.matcher(var13).matches()) {
                     this.getLogger().at(Level.WARNING).log("Corrupt line in CommonAssetsIndex.hashes:L%d '%s'", var10, var11);
                  } else {
                     String var14 = var12[1];
                     Path var15 = this.resolveCommonAssetIndexPath(var4, var14, "CommonAssetsIndex.hashes", var10);
                     if (var15 != null) {
                        this.addCommonAsset(var1.getName(), new FileCommonAsset(var15, var14, var13, null), false);
                        this.getLogger().at(Level.FINEST).log("Loaded asset info from CommonAssetsIndex.hashes:L%d '%s'", var10, var14);
                        var7++;
                     }
                  }
               }
            }

            var10++;
         }
      } catch (IOException var18) {
         ((HytaleLogger.Api)this.getLogger().at(Level.WARNING).withCause(var18)).log("Failed to load hashes from CommonAssetsIndex.hashes");
         class="kw">return false;
      }

      long var19 = System.nanoTime();
      long var21 = var19 - var5;
      this.getLogger().at(Level.INFO).log("Took %s to load %d assets from CommonAssetsIndex.hashes file.", FormatUtil.nanosToString(var21), var7);
      class="kw">return true;
   }

   class="kw">private void readCommonAssetsIndexCache(@Nonnull AssetPack var1) {
      Path var2 = var1.getRoot();
      Path var3 = var2.resolve("CommonAssetsIndex.cache");
      if (Files.isRegularFile(var3)) {
         Path var4 = this.resolveCommonAssetsRoot(var1, "CommonAssetsIndex.cache");
         if (var4 != null) {
            long var5 = System.nanoTime();
            AtomicInteger var7 = new AtomicInteger();
            List var8 = new ObjectArrayList();

            try (BufferedReader var9 = Files.newBufferedReader(var3)) {
               int var10 = 0;
               int var11 = 0;

               while (true) {
                  String var12 = var9.readLine();
                  if (var12 == null) {
                     break;
                  }

                  if (var12.startsWith("VERSION=")) {
                     var10 = Integer.parseInt(var12.substring("VERSION=".length()));
                     this.getLogger().at(Level.FINEST).log("Version set to %d from CommonAssetsIndex.cache:L%d '%s'", var10, var11, var12);
                     if (var10 > 1) {
                        throw new IllegalArgumentException(String.format("Unsupported version %d in CommonAssetsIndex.cache %d > %d", var10, var10, 1));
                     }
                  } else {
                     int var13 = var12.indexOf(32);
                     int var14 = var12.indexOf(32, var13 + 1);
                     if (var14 < 0) {
                        this.getLogger().at(Level.WARNING).log("Corrupt line in CommonAssetsIndex.cache:L%d '%s'", var11, var12);
                     } else {
                        String var15 = var12.substring(0, var13);
                        if (!CommonAsset.HASH_PATTERN.matcher(var15).matches()) {
                           this.getLogger().at(Level.WARNING).log("Corrupt line in CommonAssetsIndex.cache:L%d '%s'", var11, var12);
                        } else {
                           long var17 = Long.parseLong(var12, var13 + 1, var14, 10);
                           Instant var16;
                           if (var10 > 0) {
                              var16 = Instant.ofEpochSecond(var17);
                           } else {
                              long var19 = var17 / 10000L;
                              var16 = TICK_TIMESTAMP_ORIGIN.plusMillis(var19);
                           }

                           String var26 = var12.substring(var14 + 1);
                           int var20 = var11;
                           var8.add(
                              CompletableFuture.supplyAsync(
                                 () -> {
                                    Path var8 = this.resolveCommonAssetIndexPath(var4, var26, "CommonAssetsIndex.cache", var20);
                                    if (var8 == null) {
                                       class="kw">return null;
                                    }

                                    BasicFileAttributes var9;
                                    try {
                                       var9 = Files.readAttributes(var8, BasicFileAttributes.class);
                                    } catch (IOException var11) {
                                       class="kw">return null;
                                    }

                                    if (!var9.isRegularFile()) {
                                       class="kw">return null;
                                    }

                                    Instant var10 = var9.lastModifiedTime().toInstant().truncatedTo(ChronoUnit.SECONDS);
                                    if (var16.equals(var10)) {
                                       this.addCommonAsset(var1.getName(), new FileCommonAsset(var8, var26, var15, null), false);
                                       this.getLogger().at(Level.FINEST).log("Loaded asset info from CommonAssetsIndex.cache:L%d '%s'", var20, var26);
                                       var7.getAndIncrement();
                                    } else {
                                       this.getLogger()
                                          .at(Level.FINEST)
                                          .log(
                                             "Skipped outdated asset from CommonAssetsIndex.cache:L%d '%s', Timestamp: %s, Last Modified: %s",
                                             var20,
                                             var26,
                                             var16,
                                             var10
                                          );
                                    }

                                    class="kw">return null;
                                 }
                              )
                           );
                        }
                     }
                  }

                  var11++;
               }
            } catch (IOException var23) {
               ((HytaleLogger.Api)this.getLogger().at(Level.WARNING).withCause(var23)).log("Failed to load hashes from CommonAssetsIndex.cache");
            }

            CompletableFuture.allOf(var8.toArray(CompletableFuture[]::new)).join();
            long var24 = System.nanoTime();
            long var25 = var24 - var5;
            this.getLogger().at(Level.INFO).log("Took %s to load %d assets from CommonAssetsIndex.cache file.", FormatUtil.nanosToString(var25), var7.get());
         }
      }
   }

   @Nullable
   class="kw">private Path resolveCommonAssetsRoot(@Nonnull AssetPack var1, @Nonnull String var2) {
      try {
         Path var3 = var1.getRoot().toRealPath();
         Path var4 = var3.resolve("Common").toRealPath();
         if (!var4.equals(var3) && PathUtil.isChildOf(var3, var4) && Files.isDirectory(var4)) {
            class="kw">return var4;
         }
      } catch (IOException var5) {
         ((HytaleLogger.Api)this.getLogger().at(Level.WARNING).withCause(var5)).log("Invalid Common directory for %s in asset pack '%s'", var2, var1.getName());
         class="kw">return null;
      }

      this.getLogger().at(Level.WARNING).log("Invalid Common directory for %s in asset pack '%s'", var2, var1.getName());
      class="kw">return null;
   }

   @Nullable
   class="kw">private Path resolveCommonAssetIndexPath(@Nonnull Path var1, @Nonnull String var2, @Nonnull String var3, int var4) {
      Path var5;
      try {
         var5 = PathUtil.resolvePathWithinDir(var1, var2);
      } catch (InvalidPathException var8) {
         var5 = null;
      }

      if (var5 == null) {
         this.getLogger().at(Level.WARNING).log("Invalid asset path in %s:L%d '%s'", var3, var4, var2);
         class="kw">return null;
      }

      try {
         Path var6 = var5.toRealPath();
         if (!PathUtil.isChildOf(var1, var6)) {
            this.getLogger().at(Level.WARNING).log("Invalid asset path in %s:L%d '%s'", var3, var4, var2);
            class="kw">return null;
         } else {
            class="kw">return Files.isRegularFile(var6) ? var6 : null;
         }
      } catch (IOException var7) {
         class="kw">return null;
      }
   }

   class="kw">private void walkFileTree(@Nonnull class="kw">final AssetPack var1) class="kw">throws IOException {
      Path var2 = var1.getRoot();
      Path var3 = var2.resolve("Common").toAbsolutePath();
      if (Files.exists(var3)) {
         class="kw">final int var4 = var3.toString().length() + 1;
         long var5 = System.nanoTime();
         class="kw">final ObjectArrayList var7 = new ObjectArrayList();
         Files.walkFileTree(var3, FileUtil.DEFAULT_WALK_TREE_OPTIONS_SET, Integer.MAX_VALUE, new SimpleFileVisitor<Path>() {
            @Nonnull
            class="kw">public FileVisitResult visitFile(@Nonnull Path var1x, @Nonnull BasicFileAttributes var2) class="kw">throws IOException {
               if (!var2.isRegularFile()) {
                  class="kw">return FileVisitResult.CONTINUE;
               }

               Path var3 = var1x.getFileName();
               if (CommonAssetModule.IGNORED_FILES.contains(var3)) {
                  String var5 = PatternUtil.replaceBackslashWithForwardSlash(var1x.toString().substring(var4));
                  CommonAssetModule.this.getLogger().at(Level.FINEST).log("Skipping ignored file at %s", var5);
                  class="kw">return FileVisitResult.CONTINUE;
               }

               if (var3.toString().endsWith(".hash")) {
                  Files.deleteIfExists(var1x);
                  class="kw">return FileVisitResult.CONTINUE;
               }

               String var4x = PatternUtil.replaceBackslashWithForwardSlash(var1x.toString().substring(var4));
               if (CommonAssetRegistry.hasCommonAsset(var1, var4x)) {
                  class="kw">return FileVisitResult.CONTINUE;
               }

               CommonAssetModule.this.getLogger().at(Level.FINER).log("Loading asset: %s", var4x);
               var7.add(CompletableFuture.supplyAsync(SneakyThrow.sneakySupplier(() -> Files.readAllBytes(var1x))).thenAcceptAsync(var4xx -> {
                  FileCommonAsset var5 = new FileCommonAsset(var1x, var4x, var4xx);
                  CommonAssetModule.this.addCommonAsset(var1.getName(), var5, false);
                  CommonAssetModule.this.getLogger().at(Level.FINER).log("Loaded asset: %s", var5);
               }).exceptionally(var2x -> {
                  ((HytaleLogger.Api)CommonAssetModule.this.getLogger().at(Level.FINE).withCause(var2x)).log("Failed to load asset: %s", var4x);
                  throw SneakyThrow.sneakyThrow(var2x);
               }));
               class="kw">return FileVisitResult.CONTINUE;
            }
         });
         CompletableFuture.allOf((CompletableFuture<?>[])var7.toArray(CompletableFuture[]::new)).join();
         this.assets.invalidate();
         long var8 = System.nanoTime();
         long var10 = var8 - var5;
         this.getLogger().at(Level.INFO).log("Took %s to walk file tree and load %d assets.", FormatUtil.nanosToString(var10), var7.size());
      }
   }

   class="kw">private void unregisterAssetMonitor(@Nonnull AssetPack var1) {
      AssetMonitor var2 = AssetModule.get().getAssetMonitor();
      if (var2 != null) {
         var2.removeMonitorDirectoryFiles(var1.getRoot().resolve("Common"), var1);
      }
   }

   class="kw">private void reloadAsset(@Nonnull List<CompletableFuture<Void>> var1, String var2, @Nonnull Path var3, @Nonnull String var4) {
      this.getLogger().at(Level.FINEST).log("Reloading: %s", var3);
      var1.add(
         CompletableFuture.supplyAsync(SneakyThrow.sneakySupplier(() -> Files.readAllBytes(var3)))
            .thenAcceptAsync(var4x -> this.addCommonAsset(var2, new FileCommonAsset(var3, var4, var4x)))
            .exceptionally(var2x -> {
               if (var2x class="kw">instanceof NoSuchFileException) {
                  var2x = new SkipSentryException(var2x);
               }

               ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var2x)).log("Failed to reload asset: %s", var3);
               class="kw">return null;
            })
      );
   }

   class="kw">private void onSendCommonAssets(@Nonnull SendCommonAssetsEvent var1) {
      this.sendAssetsToPlayer(var1.getPacketHandler(), var1.getRequestedAssets(), true);
   }

   class="kw">public void sendAssetsToPlayer(@Nonnull PacketHandler var1, @Nullable Asset[] var2, boolean var3) {
      List var4 = new ObjectArrayList();
      if (var2 != null) {
         for (Asset var8 : var2) {
            CommonAsset var9 = CommonAssetRegistry.getByHash(var8.hash);
            Objects.requireNonNull(var9, var8.hash);
            var4.add(var9);
         }
      } else {
         for (List var11 : CommonAssetRegistry.getAllAssets()) {
            var4.add(var11.getLast().asset());
         }
      }

      this.getLogger().at(Level.FINE).log("%s requested %d assets!", var1.getIdentifier(), var4.size());
      this.sendAssetsToPlayer(var1, var4, var3);
   }

   class="kw">public void sendAssets(@Nonnull List<CommonAsset> var1, boolean var2) {
      for (int var3 = 0; var3 < var1.size(); var3++) {
         CommonAsset var4 = var1.get(var3);
         byte[] var5 = var4.getBlob().join();
         byte[][] var6 = ArrayUtil.split(var5, 2621440);
         ToClientPacket[] var7 = new ToClientPacket[2 + var6.length];
         var7[0] = new AssetInitialize(var4.toPacket(), var5.length);

         for (int var8 = 0; var8 < var6.length; var8++) {
            var7[1 + var8] = new AssetPart(var6[var8]);
         }

         var7[var7.length - 1] = new AssetFinalize();
         Universe.get().broadcastPacket(var7);
      }

      if (!var1.isEmpty() && var2) {
         Universe.get().broadcastPacketNoCache(new RequestCommonAssetsRebuild());
      }
   }

   class="kw">public void sendAssetsToPlayer(@Nonnull PacketHandler var1, @Nonnull List<CommonAsset> var2, boolean var3) {
      for (int var4 = 0; var4 < var2.size(); var4++) {
         int var5 = MathUtil.getPercentageOf(var4, var2.size());
         CommonAsset var6 = var2.get(var4);
         byte[] var7 = var6.getBlob().join();
         byte[][] var8 = ArrayUtil.split(var7, 2621440);
         ToClientPacket[] var9 = new ToClientPacket[2 + var8.length * 2];
         var9[0] = new AssetInitialize(var6.toPacket(), var7.length);

         for (int var10 = 0; var10 < var8.length; var10++) {
            var9[1 + var10 * 2] = new WorldLoadProgress(
               Message.translation("client.general.worldLoad.loadingAsset").param("assetName", var6.getName()).getFormattedMessage(),
               var5,
               100 * var10 / var8.length
            );
            var9[1 + var10 * 2 + 1] = new AssetPart(var8[var10]);
         }

         var9[var9.length - 1] = new AssetFinalize();
         var1.write(var9);
      }

      if (!var2.isEmpty() && var3) {
         var1.writeNoCache(new RequestCommonAssetsRebuild());
      }
   }

   class="kw">public void sendAsset(@Nonnull CommonAsset var1, boolean var2) {
      var1.getBlob().whenComplete((var3, var4) -> {
         if (var4 != null) {
            this.getLogger().at(Level.WARNING).log("Failed to send asset: %s, %s", var1.getName(), var1.getHash());
         } else {
            byte[][] var5 = ArrayUtil.split(var3, 2621440);
            ToClientPacket[] var6 = new ToClientPacket[2 + (var2 ? 1 : 0) + var5.length];
            var6[0] = new AssetInitialize(var1.toPacket(), var3.length);

            for (int var7 = 0; var7 < var5.length; var7++) {
               var6[1 + var7] = new AssetPart(var5[var7]);
            }

            var6[1 + var5.length] = new AssetFinalize();
            if (var2) {
               var6[2 + var5.length] = new RequestCommonAssetsRebuild();
            }

            Universe.get().broadcastPacket(var6);
         }
      });
   }

   class="kw">public void sendRemoveAssets(@Nonnull List<CommonAssetRegistry.PackAsset> var1, boolean var2) {
      int var3 = var1.size();
      Asset[] var4 = new Asset[var3];
      String var5 = "server.general.assetstore.removedAssets";
      String var6 = "#FF3874";
      String var7 = "Icons/AssetNotifications/Trash.png";
      Message var8 = Message.translation("server.general.assetstore.removedAssets").param("class", "Common").color("#FF3874");
      int var9 = 5;
      int var10 = 1 + (var2 ? 1 : 0) + (var1.size() < 5 ? var1.size() : 1);
      ToClientPacket[] var11 = new ToClientPacket[var10];
      int var12 = 0;

      for (CommonAssetRegistry.PackAsset var14 : var1) {
         var4[var12++] = var14.asset().toPacket();
      }

      if (var1.size() < 5) {
         var12 = 0;

         for (CommonAssetRegistry.PackAsset var21 : var1) {
            Message var15 = Message.raw(var21.pack() + ":" + var21.asset().getName()).color("#FF3874");
            var11[var12++] = new Notification(
               var8.getFormattedMessage(), var15.getFormattedMessage(), "Icons/AssetNotifications/Trash.png", null, NotificationStyle.Default, null
            );
         }

         var11[var12++] = new RemoveAssets(var4);
         if (var2) {
            var11[var12++] = new RequestCommonAssetsRebuild();
         }
      } else {
         Message var20 = Message.translation("server.general.assetstore.removedAssetsSecondaryGeneric").param("count", var1.size());
         var11[0] = new Notification(
            var8.getFormattedMessage(), var20.getFormattedMessage(), "Icons/AssetNotifications/Trash.png", null, NotificationStyle.Default, null
         );
         var11[1] = new RemoveAssets(var4);
         if (var2) {
            var11[2] = new RequestCommonAssetsRebuild();
         }
      }

      Universe.get().broadcastPacket(var11);
   }

   class="kw">private class CommonAssetMonitorHandler class="kw">implements AssetMonitorHandler {
      class="kw">private class="kw">final AssetPack pack;
      class="kw">private class="kw">final Path commonPath;

      class="kw">public CommonAssetMonitorHandler(AssetPack nullx, Path nullxx) {
         this.pack = nullx;
         this.commonPath = nullxx;
      }

      @Override
      class="kw">public Object getKey() {
         class="kw">return this.pack;
      }

      class="kw">public boolean test(Path var1, EventKind var2) {
         class="kw">return !CommonAssetModule.IGNORED_FILES.contains(var1.getFileName());
      }

      class="kw">public void accept(Map<Path, EventKind> var1) {
         List var2 = new ObjectArrayList();
         List var3 = new ObjectArrayList();
         List var4 = new ObjectArrayList();
         List var5 = new ObjectArrayList();

         for (Entry var7 : var1.entrySet()) {
            Path var8 = var7.getKey();
            EventKind var9 = var7.getValue();
            class="kw">switch (var9) {
               case ENTRY_CREATE:
                  if (Files.isDirectory(var8)) {
                     CommonAssetModule.this.getLogger().at(Level.INFO).log("Directory Created: %s", var8);

                     try (Stream var24 = Files.walk(var8, FileUtil.DEFAULT_WALK_TREE_OPTIONS_ARRAY)) {
                        var24.forEach(var3x -> {
                           BasicFileAttributes var4;
                           try {
                              var4 = Files.readAttributes(var3x, BasicFileAttributes.class);
                           } catch (IOException var6) {
                              class="kw">return;
                           }

                           if (var4.isDirectory()) {
                              var4.add(var8);
                           } else if (var4.isRegularFile()) {
                              var2.add(var3x);
                           }
                        });
                     } catch (IOException var17) {
                        ((HytaleLogger.Api)CommonAssetModule.this.getLogger().at(Level.SEVERE).withCause(var17))
                           .log("Failed to reload assets in directory: %s", var8);
                     }
                  } else {
                     CommonAssetModule.this.getLogger().at(Level.INFO).log("File Created: %s", var8);
                     var2.add(var8);
                  }
                  break;
               case ENTRY_DELETE:
                  CommonAssetModule.this.getLogger().at(Level.INFO).log("Deleted: %s", var8);
                  var5.add(var8);
                  Path var10 = PathUtil.relativize(this.commonPath, var8);
                  String var11 = PatternUtil.replaceBackslashWithForwardSlash(var10.toString());

                  for (CommonAsset var14 : CommonAssetRegistry.getCommonAssetsStartingWith(this.pack.getName(), var11)) {
                     var3.add(this.commonPath.resolve(var14.getName()));
                  }
                  break;
               case ENTRY_MODIFY:
                  if (Files.isDirectory(var8)) {
                     CommonAssetModule.this.getLogger().at(Level.INFO).log("Directory Modified: %s", var8);
                     var4.add(var8);
                  } else {
                     CommonAssetModule.this.getLogger().at(Level.INFO).log("File Modified: %s", var8);
                     var2.add(var8);
                  }
            }
         }

         if (!var5.isEmpty() || !var2.isEmpty() || !var4.isEmpty()) {
            IEventDispatcher var18 = HytaleServer.get().getEventBus().dispatchFor(CommonAssetMonitorEvent.class);
            if (var18.hasListener()) {
               var18.dispatch(new CommonAssetMonitorEvent(this.pack.getName(), var2, var3, var4, var5));
            }
         }

         List var19 = new ObjectArrayList();
         List var20 = new ObjectArrayList();
         List var21 = new ObjectArrayList();
         if (!var3.isEmpty()) {
            CommonAssetModule.this.getLogger().at(Level.INFO).log("Removing deleted assets: %s", var3);

            for (Path var25 : var3) {
               Path var27 = PathUtil.relativize(this.commonPath, var25);
               String var29 = PatternUtil.replaceBackslashWithForwardSlash(var27.toString());
               BooleanObjectPair var31 = CommonAssetRegistry.removeCommonAssetByName(this.pack.getName(), var29);
               if (var31 != null) {
                  if (var31.firstBoolean()) {
                     var21.add(((CommonAssetRegistry.PackAsset)var31.second()).asset());
                  } else {
                     var20.add((CommonAssetRegistry.PackAsset)var31.second());
                  }
               }

               CommonAssetModule.this.assets.invalidate();
            }

            CommonAssetModule.this.sendRemoveAssets(var20, false);
            CommonAssetModule.this.sendAssets(var21, false);
         }

         if (!var2.isEmpty()) {
            CommonAssetModule.this.getLogger().at(Level.INFO).log("Reloading assets: %s", var2);

            for (Path var26 : var2) {
               Path var28 = PathUtil.relativize(this.commonPath, var26);
               String var30 = PatternUtil.replaceBackslashWithForwardSlash(var28.toString());
               CommonAssetModule.this.reloadAsset(var19, this.pack.getName(), var26, var30);
            }

            CompletableFuture.allOf(var19.toArray(CompletableFuture[]::new))
               .thenAccept(var0 -> Universe.get().broadcastPacketNoCache(new RequestCommonAssetsRebuild()));
         } else {
            Universe.get().broadcastPacketNoCache(new RequestCommonAssetsRebuild());
         }
      }
   }
}