class="kw">package com.hypixel.hytale.builtin.asseteditor;

class="kw">import com.hypixel.hytale.builtin.asseteditor.assettypehandler.AssetTypeHandler;
class="kw">import com.hypixel.hytale.builtin.asseteditor.data.AssetState;
class="kw">import com.hypixel.hytale.builtin.asseteditor.data.ModifiedAsset;
class="kw">import com.hypixel.hytale.builtin.asseteditor.util.AssetPathUtil;
class="kw">import com.hypixel.hytale.common.util.FormatUtil;
class="kw">import com.hypixel.hytale.common.util.ListUtil;
class="kw">import com.hypixel.hytale.common.util.PathUtil;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.packets.asseteditor.AssetEditorAssetListSetup;
class="kw">import com.hypixel.hytale.protocol.packets.asseteditor.AssetEditorFileEntry;
class="kw">import com.hypixel.hytale.protocol.packets.asseteditor.AssetEditorFileTree;
class="kw">import com.hypixel.hytale.server.core.asset.common.CommonAssetModule;
class="kw">import com.hypixel.hytale.server.core.util.io.FileUtil;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
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.Path;
class="kw">import java.nio.file.SimpleFileVisitor;
class="kw">import java.nio.file.attribute.BasicFileAttributes;
class="kw">import java.util.Collection;
class="kw">import java.util.Comparator;
class="kw">import java.util.HashSet;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.concurrent.locks.StampedLock;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class AssetTree {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">final StampedLock lock = new StampedLock();
   class="kw">private class="kw">final Path rootPath;
   class="kw">private class="kw">final String packKey;
   class="kw">private class="kw">final boolean isReadOnly;
   class="kw">private class="kw">final boolean canBeDeleted;
   List<AssetEditorFileEntry> serverAssets = new ObjectArrayList();
   List<AssetEditorFileEntry> commonAssets = new ObjectArrayList();

   class="kw">public AssetTree(Path var1, String var2, boolean var3, boolean var4) {
      this.rootPath = var1;
      this.packKey = var2;
      this.isReadOnly = var3;
      this.canBeDeleted = var4;
   }

   class="kw">public AssetTree(Path var1, String var2, boolean var3, boolean var4, @Nonnull Collection<AssetTypeHandler> var5) {
      this.rootPath = var1;
      this.packKey = var2;
      this.isReadOnly = var3;
      this.canBeDeleted = var4;
      this.load(var5);
   }

   class="kw">public void replaceAssetTree(@Nonnull AssetTree var1) {
      long var2 = this.lock.writeLock();

      try {
         this.serverAssets = var1.serverAssets;
         this.commonAssets = var1.commonAssets;
      } class="kw">finally {
         this.lock.unlockWrite(var2);
      }
   }

   class="kw">public void sendPackets(@Nonnull EditorClient var1) {
      long var2 = this.lock.readLock();

      try {
         var1.getPacketHandler()
            .write(
               new AssetEditorAssetListSetup(
                  this.packKey, this.isReadOnly, this.canBeDeleted, AssetEditorFileTree.Server, this.serverAssets.toArray(AssetEditorFileEntry[]::new)
               )
            );
         var1.getPacketHandler()
            .write(
               new AssetEditorAssetListSetup(
                  this.packKey, this.isReadOnly, this.canBeDeleted, AssetEditorFileTree.Common, this.commonAssets.toArray(AssetEditorFileEntry[]::new)
               )
            );
      } class="kw">finally {
         this.lock.unlockRead(var2);
      }
   }

   class="kw">public boolean isDirectoryEmpty(@Nonnull Path var1) {
      String var2 = PathUtil.toUnixPathString(var1);
      long var3 = this.lock.readLock();

      try {
         List var5 = this.getAssetListForPath(var1);
         int var6 = ListUtil.binarySearch(var5, var0 -> var0.path, var2, String::compareTo);
         if (var6 < 0) {
            class="kw">return true;
         }

         if (!var5.get(var6).isDirectory) {
            class="kw">return false;
         }

         int var7 = var6 + 1;
         if (var7 >= var5.size()) {
            class="kw">return false;
         }

         boolean var8 = var5.get(var7).path.startsWith(var2 + "/");
         class="kw">return !var8;
      } class="kw">finally {
         this.lock.unlockRead(var3);
      }
   }

   @Nullable
   class="kw">public AssetEditorFileEntry ensureAsset(@Nonnull Path var1, boolean var2) {
      String var3 = PathUtil.toUnixPathString(var1);
      long var4 = this.lock.writeLock();

      try {
         List var6 = this.getAssetListForPath(var1);
         int var7 = ListUtil.binarySearch(var6, var0 -> var0.path, var3, String::compareTo);
         if (var7 >= 0) {
            class="kw">return null;
         }

         int var8 = -(var7 + 1);
         if (var1.getNameCount() > 1) {
            Path var9 = var1.getName(0);

            for (int var10 = 1; var10 < var1.getNameCount() - 1; var10++) {
               var9 = var9.resolve(var1.getName(var10));
               String var11 = PathUtil.toUnixPathString(var9);
               if (var8 <= 0 || !var6.get(var8 - 1).path.startsWith(var11)) {
                  var6.add(var8++, new AssetEditorFileEntry(var11, true));
               }
            }
         }

         AssetEditorFileEntry var15 = new AssetEditorFileEntry(var3, var2);
         var6.add(var8, var15);
         class="kw">return var15;
      } class="kw">finally {
         this.lock.unlockWrite(var4);
      }
   }

   @Nonnull
   class="kw">public List<Path> findAssetFilesByFilename(@Nonnull Path var1, @Nonnull String var2) {
      String var3 = PathUtil.toUnixPathString(var1) + "/";
      List var4 = new ObjectArrayList();
      long var5 = this.lock.readLock();

      try {
         for (AssetEditorFileEntry var9 : this.getAssetListForPath(var1)) {
            if (!var9.isDirectory && var9.path.startsWith(var3)) {
               int var10 = var9.path.lastIndexOf("/");
               String var11 = var10 < 0 ? var9.path : var9.path.substring(var10 + 1);
               if (var11.equalsIgnoreCase(var2)) {
                  var4.add(Path.of(var9.path));
               }
            }
         }
      } class="kw">finally {
         this.lock.unlockRead(var5);
      }

      class="kw">return var4;
   }

   @Nullable
   class="kw">public AssetEditorFileEntry getAssetFile(@Nonnull Path var1) {
      String var2 = PathUtil.toUnixPathString(var1);
      long var3 = this.lock.readLock();

      try {
         List var5 = this.getAssetListForPath(var1);
         int var6 = ListUtil.binarySearch(var5, var0 -> var0.path, var2, String::compareTo);
         class="kw">return var6 >= 0 ? var5.get(var6) : null;
      } class="kw">finally {
         this.lock.unlockRead(var3);
      }
   }

   @Nullable
   class="kw">public AssetEditorFileEntry removeAsset(@Nonnull Path var1) {
      String var2 = PathUtil.toUnixPathString(var1);
      long var3 = this.lock.writeLock();

      try {
         List var5 = this.getAssetListForPath(var1);
         int var6 = ListUtil.binarySearch(var5, var0 -> var0.path, var2, String::compareTo);
         if (var6 < 0) {
            class="kw">return null;
         }

         AssetEditorFileEntry var7 = var5.remove(var6);
         if (var7.isDirectory) {
            String var8 = var2 + "/";
            int var9 = 0;

            for (int var10 = var6; var10 < var5.size(); var10++) {
               AssetEditorFileEntry var11 = var5.get(var10);
               if (!var11.path.startsWith(var8)) {
                  break;
               }

               var9++;
            }

            for (int var15 = 0; var15 < var9; var15++) {
               var5.remove(var6);
            }
         }

         class="kw">return var7;
      } class="kw">finally {
         this.lock.unlockWrite(var3);
      }
   }

   class="kw">public void applyAssetChanges(@Nonnull Map<Path, ModifiedAsset> var1, @Nonnull Map<Path, ModifiedAsset> var2) {
      for (ModifiedAsset var4 : var1.values()) {
         this.ensureAsset(var4.path, true);
      }

      for (ModifiedAsset var6 : var2.values()) {
         if (var6.state == AssetState.NEW) {
            this.ensureAsset(var6.path, false);
         } else if (var6.state == AssetState.DELETED) {
            this.removeAsset(var6.oldPath != null ? var6.oldPath : var6.path);
         } else if (var6.oldPath != null) {
            this.removeAsset(var6.oldPath);
            this.ensureAsset(var6.path, false);
         }
      }
   }

   class="kw">private List<AssetEditorFileEntry> getAssetListForPath(@Nonnull Path var1) {
      if (var1.getNameCount() > 0) {
         String var2 = var1.getName(0).toString();
         if (var2.equals("..")) {
            try {
               var2 = var1.getName(2).toString();
            } catch (IllegalArgumentException var4) {
            }
         }

         if ("Server".equals(var2)) {
            class="kw">return this.serverAssets;
         }

         if ("Common".equals(var2)) {
            class="kw">return this.commonAssets;
         }
      }

      throw new IllegalArgumentException("Invalid path " + var1);
   }

   class="kw">private void load(@Nonnull Collection<AssetTypeHandler> var1) {
      try {
         long var2 = System.nanoTime();
         loadServerAssets(this.rootPath, var1, this.serverAssets);
         LOGGER.at(Level.INFO).log("Loaded Server/ asset tree! Took: %s", FormatUtil.nanosToString(System.nanoTime() - var2));
      } catch (IOException var5) {
         ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var5)).log("Failed to load server asset tree!");
      }

      try {
         long var6 = System.nanoTime();
         walkFileTree(this.rootPath, this.rootPath.resolve("Common"), this.commonAssets);
         LOGGER.at(Level.INFO).log("Loaded Common/ asset tree! Took: %s", FormatUtil.nanosToString(System.nanoTime() - var6));
      } catch (IOException var4) {
         ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var4)).log("Failed to load common asset tree!");
      }

      long var7 = System.nanoTime();
      this.serverAssets.sort(Comparator.comparing(var0 -> var0.path));
      this.commonAssets.sort(Comparator.comparing(var0 -> var0.path));
      LOGGER.at(Level.INFO).log("Sorted asset tree! Took: %s", FormatUtil.nanosToString(System.nanoTime() - var7));
   }

   class="kw">private class="kw">static void loadServerAssets(@Nonnull Path var0, @Nonnull Collection<AssetTypeHandler> var1, @Nonnull List<AssetEditorFileEntry> var2) class="kw">throws IOException {
      Set var3 = new HashSet<>();
      Set var4 = new HashSet<>();

      for (AssetTypeHandler var6 : var1) {
         if (var6.getRootPath().startsWith(AssetPathUtil.PATH_DIR_SERVER)) {
            String var7 = var6.getConfig().path;
            if (var3.add(var7)) {
               Path var8 = Path.of(var7);
               Path var9 = AssetPathUtil.PATH_DIR_SERVER;

               for (int var10 = 1; var10 < var8.getNameCount() - 1; var10++) {
                  var9 = var9.resolve(var8.getName(var10));
                  String var11 = PathUtil.toUnixPathString(var9);
                  if (var4.add(var11)) {
                     var2.add(new AssetEditorFileEntry(var11, true));
                  }
               }
            }
         }
      }

      for (String var13 : var3) {
         Path var14 = var0.resolve(var13);
         walkFileTree(var0, var14, var2);
         String var15 = PathUtil.toUnixPathString(var0.relativize(var14));
         var2.add(new AssetEditorFileEntry(var15, true));
      }
   }

   class="kw">private class="kw">static void walkFileTree(@Nonnull class="kw">final Path var0, @Nonnull class="kw">final Path var1, @Nonnull class="kw">final List<AssetEditorFileEntry> var2) class="kw">throws IOException {
      if (Files.isDirectory(var1)) {
         Files.walkFileTree(var1, FileUtil.DEFAULT_WALK_TREE_OPTIONS_SET, Integer.MAX_VALUE, new SimpleFileVisitor<Path>() {
            class="kw">public FileVisitResult preVisitDirectory(Path var1x, BasicFileAttributes var2x) class="kw">throws IOException {
               if (var1x.equals(var1)) {
                  class="kw">return FileVisitResult.CONTINUE;
               }

               var2.add(new AssetEditorFileEntry(PathUtil.toUnixPathString(var0.relativize(var1x)), true));
               class="kw">return super.preVisitDirectory(var1x, var2x);
            }

            @Nonnull
            class="kw">public FileVisitResult visitFile(@Nonnull Path var1x, @Nonnull BasicFileAttributes var2x) {
               if (CommonAssetModule.IGNORED_FILES.contains(var1x.getFileName())) {
                  class="kw">return FileVisitResult.CONTINUE;
               }

               var2.add(new AssetEditorFileEntry(PathUtil.toUnixPathString(var0.relativize(var1x)), false));
               class="kw">return FileVisitResult.CONTINUE;
            }
         });
      }
   }
}