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

class="kw">import com.hypixel.hytale.common.util.SystemUtil;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.util.io.FileUtil;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import com.sun.nio.file.ExtendedWatchEventModifier;
class="kw">import com.sun.nio.file.SensitivityWatchEventModifier;
class="kw">import java.io.IOException;
class="kw">import java.nio.file.FileSystems;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.nio.file.StandardWatchEventKinds;
class="kw">import java.nio.file.WatchEvent;
class="kw">import java.nio.file.WatchKey;
class="kw">import java.nio.file.WatchService;
class="kw">import java.nio.file.WatchEvent.Kind;
class="kw">import java.nio.file.WatchEvent.Modifier;
class="kw">import java.util.Map;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.function.BiConsumer;
class="kw">import java.util.logging.Level;
class="kw">import java.util.stream.Stream;
class="kw">import javax.annotation.Nonnull;

class="kw">public class PathWatcherThread class="kw">implements Runnable {
   class="kw">public class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">public class="kw">static class="kw">final boolean HAS_FILE_TREE_SUPPORT = SystemUtil.TYPE == SystemUtil.SystemType.WINDOWS;
   class="kw">public class="kw">static class="kw">final Kind<?>[] WATCH_EVENT_KINDS = new Kind[]{
      StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY
   };
   class="kw">private class="kw">final BiConsumer<Path, EventKind> consumer;
   @Nonnull
   class="kw">private class="kw">final Thread thread;
   class="kw">private class="kw">final WatchService service;
   class="kw">private class="kw">final Map<Path, WatchKey> registered = new ConcurrentHashMap<>();

   class="kw">public PathWatcherThread(BiConsumer<Path, EventKind> var1) class="kw">throws IOException {
      this.consumer = var1;
      this.thread = new Thread(this, "PathWatcher");
      this.thread.setDaemon(true);
      this.service = FileSystems.getDefault().newWatchService();
   }

   @Override
   class="kw">public class="kw">final void run() {
      try {
         while (!Thread.interrupted()) {
            WatchKey var1 = this.service.take();
            Path var2 = (Path)var1.watchable();

            for (WatchEvent var4 : var1.pollEvents()) {
               Kind var5 = var4.kind();
               if (var5 == StandardWatchEventKinds.OVERFLOW) {
                  LOGGER.at(Level.WARNING)
                     .log(
                        "Event Overflow, Unable to detect all file changed! This may cause server instability!! More than AbstractWatchKey.MAX_EVENT_LIST_SIZE queued events (512)"
                     );
               } else {
                  WatchEvent var6 = (WatchEvent<Path>)var4;
                  Path var7 = var2.resolve(var6.context());
                  if (!HAS_FILE_TREE_SUPPORT && var6.kind() == StandardWatchEventKinds.ENTRY_CREATE && Files.isDirectory(var7)) {
                     this.addPath(var7);
                  }

                  this.consumer.accept(var7, EventKind.parse(var6.kind()));
               }
            }

            if (!var1.reset()) {
               break;
            }
         }
      } catch (InterruptedException var9) {
         Thread.currentThread().interrupt();
      } catch (Throwable var10) {
         ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(var10)).log("Exception occurred when polling:");
      }

      LOGGER.at(Level.INFO).log("Stopped polling for changes in assets. Server will need to be rebooted to load changes!");

      try {
         this.service.close();
      } catch (IOException var8) {
      }

      this.registered.clear();
   }

   class="kw">public void start() {
      this.thread.start();
   }

   class="kw">public void shutdown() {
      this.thread.interrupt();

      try {
         this.thread.join(1000L);

         try {
            this.service.close();
         } catch (IOException var2) {
         }

         this.registered.clear();
      } catch (InterruptedException var3) {
         Thread.currentThread().interrupt();
      }
   }

   class="kw">public void addPath(Path var1) class="kw">throws IOException {
      var1 = var1.toAbsolutePath();
      if (Files.isRegularFile(var1)) {
         var1 = var1.getParent();
      }

      Path var2 = var1;

      do {
         WatchKey var3 = this.registered.get(var2);
         if (var3 != null) {
            if (!HAS_FILE_TREE_SUPPORT) {
               this.watchPath(var1);
            }

            class="kw">return;
         }
      } while ((var2 = var2.getParent()) != null);

      this.watchPath(var1);
   }

   class="kw">private void watchPath(@Nonnull Path var1) class="kw">throws IOException {
      if (HAS_FILE_TREE_SUPPORT) {
         this.registered.put(var1, var1.register(this.service, WATCH_EVENT_KINDS, SensitivityWatchEventModifier.HIGH, ExtendedWatchEventModifier.FILE_TREE));
         LOGGER.at(Level.FINEST).log("Register path: %s", var1);
      } else {
         Modifier[] var2 = new Modifier[]{SensitivityWatchEventModifier.HIGH};

         try (Stream var3 = Files.walk(var1, FileUtil.DEFAULT_WALK_TREE_OPTIONS_ARRAY)) {
            var3.forEach(SneakyThrow.sneakyConsumer(var2x -> {
               if (Files.isDirectory(var2x)) {
                  this.registered.put(var2x, var2x.register(this.service, WATCH_EVENT_KINDS, var2));
                  LOGGER.at(Level.FINEST).log("Register path: %s", var2x);
               }
            }));
         }
      }

      LOGGER.at(Level.FINER).log("Watching path: %s", var1);
   }
}