class="kw">package com.hypixel.hytale.metrics;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.codecs.EnumCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.MapCodec;
class="kw">import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
class="kw">import java.lang.Thread.State;
class="kw">import java.lang.management.ClassLoadingMXBean;
class="kw">import java.lang.management.GarbageCollectorMXBean;
class="kw">import java.lang.management.ManagementFactory;
class="kw">import java.lang.management.MemoryManagerMXBean;
class="kw">import java.lang.management.MemoryPoolMXBean;
class="kw">import java.lang.management.MemoryType;
class="kw">import java.lang.management.MemoryUsage;
class="kw">import java.lang.management.OperatingSystemMXBean;
class="kw">import java.lang.management.RuntimeMXBean;
class="kw">import java.lang.management.ThreadInfo;
class="kw">import java.lang.management.ThreadMXBean;
class="kw">import java.time.Duration;
class="kw">import java.time.Instant;
class="kw">import java.util.HashMap;
class="kw">import java.util.Map;
class="kw">import javax.annotation.Nonnull;

class="kw">public class JVMMetrics {
   @Nonnull
   class="kw">public class="kw">static class="kw">final MetricsRegistry<ClassLoader> CLASS_LOADER_METRICS_REGISTRY = new MetricsRegistry<>();
   @Nonnull
   class="kw">public class="kw">static class="kw">final MetricsRegistry<MemoryUsage> MEMORY_USAGE_METRICS_REGISTRY = new MetricsRegistry<>();
   @Nonnull
   class="kw">public class="kw">static class="kw">final MetricsRegistry<GarbageCollectorMXBean> GARBAGE_COLLECTOR_METRICS_REGISTRY = new MetricsRegistry<>();
   @Nonnull
   class="kw">public class="kw">static class="kw">final MetricsRegistry<MemoryPoolMXBean> MEMORY_POOL_METRICS_REGISTRY = new MetricsRegistry<>();
   @Nonnull
   class="kw">public class="kw">static class="kw">final MetricsRegistry<Void> METRICS_REGISTRY = new MetricsRegistry<>();

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

   class="kw">static {
      CLASS_LOADER_METRICS_REGISTRY.register("Name", ClassLoader::getName, Codec.STRING);
      CLASS_LOADER_METRICS_REGISTRY.register("Parent", ClassLoader::getParent, CLASS_LOADER_METRICS_REGISTRY);
      MEMORY_USAGE_METRICS_REGISTRY.register("Init", MemoryUsage::getInit, Codec.LONG);
      MEMORY_USAGE_METRICS_REGISTRY.register("Used", MemoryUsage::getUsed, Codec.LONG);
      MEMORY_USAGE_METRICS_REGISTRY.register("Committed", MemoryUsage::getCommitted, Codec.LONG);
      MEMORY_USAGE_METRICS_REGISTRY.register("Max", MemoryUsage::getMax, Codec.LONG);
      GARBAGE_COLLECTOR_METRICS_REGISTRY.register("Name", MemoryManagerMXBean::getName, Codec.STRING);
      GARBAGE_COLLECTOR_METRICS_REGISTRY.register("MemoryPoolNames", MemoryManagerMXBean::getMemoryPoolNames, Codec.STRING_ARRAY);
      GARBAGE_COLLECTOR_METRICS_REGISTRY.register("CollectionCount", GarbageCollectorMXBean::getCollectionCount, Codec.LONG);
      GARBAGE_COLLECTOR_METRICS_REGISTRY.register("CollectionTime", GarbageCollectorMXBean::getCollectionTime, Codec.LONG);
      MEMORY_POOL_METRICS_REGISTRY.register("Name", MemoryPoolMXBean::getName, Codec.STRING);
      MEMORY_POOL_METRICS_REGISTRY.register("Type", MemoryPoolMXBean::getType, new EnumCodec<>(MemoryType.class));
      MEMORY_POOL_METRICS_REGISTRY.register("PeakUsage", MemoryPoolMXBean::getPeakUsage, MEMORY_USAGE_METRICS_REGISTRY);
      MEMORY_POOL_METRICS_REGISTRY.register("Usage", MemoryPoolMXBean::getUsage, MEMORY_USAGE_METRICS_REGISTRY);
      MEMORY_POOL_METRICS_REGISTRY.register("CollectionUsage", MemoryPoolMXBean::getCollectionUsage, MEMORY_USAGE_METRICS_REGISTRY);
      MetricsRegistry var0 = new MetricsRegistry<>();
      var0.register("Threshold", MemoryPoolMXBean::getUsageThreshold, Codec.LONG);
      var0.register("ThresholdCount", MemoryPoolMXBean::getUsageThresholdCount, Codec.LONG);
      var0.register("ThresholdExceeded", MemoryPoolMXBean::isUsageThresholdExceeded, Codec.BOOLEAN);
      MEMORY_POOL_METRICS_REGISTRY.register("UsageThreshold", var0x -> !var0x.isUsageThresholdSupported() ? null : var0x, var0);
      var0 = new MetricsRegistry<>();
      var0.register("Threshold", MemoryPoolMXBean::getCollectionUsageThreshold, Codec.LONG);
      var0.register("ThresholdCount", MemoryPoolMXBean::getCollectionUsageThresholdCount, Codec.LONG);
      var0.register("ThresholdExceeded", MemoryPoolMXBean::isCollectionUsageThresholdExceeded, Codec.BOOLEAN);
      MEMORY_POOL_METRICS_REGISTRY.register("CollectionUsageThreshold", var0x -> !var0x.isCollectionUsageThresholdSupported() ? null : var0x, var0);
      var0 = new MetricsRegistry<>();
      METRICS_REGISTRY.register("PROCESSOR", var0x -> System.getenv("PROCESSOR_IDENTIFIER"), Codec.STRING);
      METRICS_REGISTRY.register("PROCESSOR_ARCHITECTURE", var0x -> System.getenv("PROCESSOR_ARCHITECTURE"), Codec.STRING);
      METRICS_REGISTRY.register("PROCESSOR_ARCHITEW6432", var0x -> System.getenv("PROCESSOR_ARCHITEW6432"), Codec.STRING);
      var0.register("OSName", OperatingSystemMXBean::getName, Codec.STRING);
      var0.register("OSArch", OperatingSystemMXBean::getArch, Codec.STRING);
      var0.register("OSVersion", OperatingSystemMXBean::getVersion, Codec.STRING);
      var0.register("AvailableProcessors", var0x -> Runtime.getRuntime().availableProcessors(), Codec.INTEGER);
      var0.register("SystemLoadAverage", OperatingSystemMXBean::getSystemLoadAverage, Codec.DOUBLE);
      if (ManagementFactory.getOperatingSystemMXBean() class="kw">instanceof com.sun.management.OperatingSystemMXBean) {
         var0.register("CpuLoad", var0x -> ((com.sun.management.OperatingSystemMXBean)var0x).getCpuLoad(), Codec.DOUBLE);
         var0.register("ProcessCpuLoad", var0x -> ((com.sun.management.OperatingSystemMXBean)var0x).getProcessCpuLoad(), Codec.DOUBLE);
         var0.register("TotalMemorySize", var0x -> ((com.sun.management.OperatingSystemMXBean)var0x).getTotalMemorySize(), Codec.LONG);
         var0.register("FreeMemorySize", var0x -> ((com.sun.management.OperatingSystemMXBean)var0x).getFreeMemorySize(), Codec.LONG);
         var0.register("TotalSwapSpaceSize", var0x -> ((com.sun.management.OperatingSystemMXBean)var0x).getTotalSwapSpaceSize(), Codec.LONG);
         var0.register("FreeSwapSpaceSize", var0x -> ((com.sun.management.OperatingSystemMXBean)var0x).getFreeSwapSpaceSize(), Codec.LONG);
      }

      METRICS_REGISTRY.register("System", var0x -> ManagementFactory.getOperatingSystemMXBean(), var0);
      var0 = new MetricsRegistry<>();
      var0.register("StartTime", var0x -> Instant.ofEpochMilli(var0x.getStartTime()), Codec.INSTANT);
      var0.register("Uptime", var0x -> Duration.ofMillis(var0x.getUptime()), Codec.DURATION);
      var0.register("RuntimeName", RuntimeMXBean::getName, Codec.STRING);
      var0.register("SpecName", RuntimeMXBean::getSpecName, Codec.STRING);
      var0.register("SpecVendor", RuntimeMXBean::getSpecVendor, Codec.STRING);
      var0.register("SpecVersion", RuntimeMXBean::getSpecVersion, Codec.STRING);
      var0.register("ManagementSpecVersion", RuntimeMXBean::getManagementSpecVersion, Codec.STRING);
      var0.register("VMName", RuntimeMXBean::getVmName, Codec.STRING);
      var0.register("VMVendor", RuntimeMXBean::getVmVendor, Codec.STRING);
      var0.register("VMVersion", RuntimeMXBean::getVmVersion, Codec.STRING);
      var0.register("LibraryPath", RuntimeMXBean::getLibraryPath, Codec.STRING);

      try {
         ManagementFactory.getRuntimeMXBean().getBootClassPath();
         var0.register("BootClassPath", RuntimeMXBean::getBootClassPath, Codec.STRING);
      } catch (UnsupportedOperationException var2) {
      }

      var0.register("ClassPath", RuntimeMXBean::getClassPath, Codec.STRING);
      var0.register("InputArguments", var0x -> var0x.getInputArguments().toArray(String[]::new), Codec.STRING_ARRAY);
      var0.register("SystemProperties", RuntimeMXBean::getSystemProperties, new MapCodec<>(Codec.STRING, HashMap::new));
      METRICS_REGISTRY.register("Runtime", var0x -> ManagementFactory.getRuntimeMXBean(), var0);
      var0 = new MetricsRegistry<>();
      var0.register("ObjectPendingFinalizationCount", var0x -> var0x.getObjectPendingFinalizationCount(), Codec.INTEGER);
      var0.register("HeapMemoryUsage", var0x -> var0x.getHeapMemoryUsage(), MEMORY_USAGE_METRICS_REGISTRY);
      var0.register("NonHeapMemoryUsage", var0x -> var0x.getNonHeapMemoryUsage(), MEMORY_USAGE_METRICS_REGISTRY);
      METRICS_REGISTRY.register("Memory", var0x -> ManagementFactory.getMemoryMXBean(), var0);
      METRICS_REGISTRY.register(
         "GarbageCollectors",
         var0x -> ManagementFactory.getGarbageCollectorMXBeans().toArray(GarbageCollectorMXBean[]::new),
         new ArrayCodec<>(GARBAGE_COLLECTOR_METRICS_REGISTRY, GarbageCollectorMXBean[]::new)
      );
      METRICS_REGISTRY.register(
         "MemoryPools",
         var0x -> ManagementFactory.getMemoryPoolMXBeans().toArray(MemoryPoolMXBean[]::new),
         new ArrayCodec<>(MEMORY_POOL_METRICS_REGISTRY, MemoryPoolMXBean[]::new)
      );
      METRICS_REGISTRY.register("Threads", var0x -> {
         ThreadMXBean var1 = ManagementFactory.getThreadMXBean();
         ThreadInfo[] var2 = var1.dumpAllThreads(true, true);
         Map var3 = Thread.getAllStackTraces();
         Long2ObjectOpenHashMap var4 = new Long2ObjectOpenHashMap();

         for (Thread var6 : var3.keySet()) {
            var4.put(var6.getId(), var6);
         }

         JVMMetrics.ThreadMetricData[] var8 = new JVMMetrics.ThreadMetricData[var2.length];

         for (int var9 = 0; var9 < var2.length; var9++) {
            ThreadInfo var7 = var2[var9];
            var8[var9] = new JVMMetrics.ThreadMetricData(var7, (Thread)var4.get(var7.getThreadId()), var1);
         }

         class="kw">return var8;
      }, new ArrayCodec<>(JVMMetrics.ThreadMetricData.METRICS_REGISTRY, JVMMetrics.ThreadMetricData[]::new));
      METRICS_REGISTRY.register("SecurityManager", var0x -> {
         SecurityManager var1 = System.getSecurityManager();
         class="kw">return var1 == null ? null : var1.getClass().getName();
      }, Codec.STRING);
      var0 = new MetricsRegistry<>();
      var0.register("LoadedClassCount", ClassLoadingMXBean::getLoadedClassCount, Codec.INTEGER);
      var0.register("UnloadedClassCount", ClassLoadingMXBean::getUnloadedClassCount, Codec.LONG);
      var0.register("TotalLoadedClassCount", ClassLoadingMXBean::getTotalLoadedClassCount, Codec.LONG);
      var0.register("SystemClassloader", var0x -> ClassLoader.getSystemClassLoader(), CLASS_LOADER_METRICS_REGISTRY);
      var0.register("JVMMetricsClassloader", var0x -> JVMMetrics.class.getClassLoader(), CLASS_LOADER_METRICS_REGISTRY);
      METRICS_REGISTRY.register("ClassLoading", var0x -> ManagementFactory.getClassLoadingMXBean(), var0);
   }

   class="kw">private class="kw">static class ThreadMetricData {
      @Nonnull
      class="kw">public class="kw">static class="kw">final MetricsRegistry<StackTraceElement> STACK_TRACE_ELEMENT_METRICS_REGISTRY = new MetricsRegistry<>();
      @Nonnull
      class="kw">public class="kw">static class="kw">final MetricsRegistry<JVMMetrics.ThreadMetricData> METRICS_REGISTRY = new MetricsRegistry<>();
      class="kw">private class="kw">final ThreadInfo threadInfo;
      class="kw">private class="kw">final Thread thread;
      class="kw">private class="kw">final ThreadMXBean threadMXBean;

      class="kw">public ThreadMetricData(ThreadInfo var1, Thread var2, ThreadMXBean var3) {
         this.threadInfo = var1;
         this.thread = var2;
         this.threadMXBean = var3;
      }

      class="kw">static {
         STACK_TRACE_ELEMENT_METRICS_REGISTRY.register("FileName", StackTraceElement::getFileName, Codec.STRING);
         STACK_TRACE_ELEMENT_METRICS_REGISTRY.register("LineNumber", StackTraceElement::getLineNumber, Codec.INTEGER);
         STACK_TRACE_ELEMENT_METRICS_REGISTRY.register("ModuleName", StackTraceElement::getModuleName, Codec.STRING);
         STACK_TRACE_ELEMENT_METRICS_REGISTRY.register("ModuleVersion", StackTraceElement::getModuleVersion, Codec.STRING);
         STACK_TRACE_ELEMENT_METRICS_REGISTRY.register("ClassLoaderName", StackTraceElement::getClassLoaderName, Codec.STRING);
         STACK_TRACE_ELEMENT_METRICS_REGISTRY.register("ClassName", StackTraceElement::getClassName, Codec.STRING);
         STACK_TRACE_ELEMENT_METRICS_REGISTRY.register("MethodName", StackTraceElement::getMethodName, Codec.STRING);
         METRICS_REGISTRY.register("Id", var0x -> var0x.threadInfo.getThreadId(), Codec.LONG);
         METRICS_REGISTRY.register("Name", var0x -> var0x.threadInfo.getThreadName(), Codec.STRING);
         METRICS_REGISTRY.register("State", var0x -> var0x.threadInfo.getThreadState(), new EnumCodec<>(State.class));
         METRICS_REGISTRY.register("Priority", var0x -> var0x.threadInfo.getPriority(), Codec.INTEGER);
         METRICS_REGISTRY.register("Daemon", var0x -> var0x.threadInfo.isDaemon(), Codec.BOOLEAN);
         METRICS_REGISTRY.register("CPUTime", var0x -> var0x.threadMXBean.getThreadCpuTime(var0x.threadInfo.getThreadId()), Codec.LONG);
         METRICS_REGISTRY.register("WaitedTime", var0x -> var0x.threadInfo.getWaitedTime(), Codec.LONG);
         METRICS_REGISTRY.register("WaitedCount", var0x -> var0x.threadInfo.getWaitedCount(), Codec.LONG);
         METRICS_REGISTRY.register("BlockedTime", var0x -> var0x.threadInfo.getBlockedTime(), Codec.LONG);
         METRICS_REGISTRY.register("BlockedCount", var0x -> var0x.threadInfo.getBlockedCount(), Codec.LONG);
         METRICS_REGISTRY.register("LockName", var0x -> var0x.threadInfo.getLockName(), Codec.STRING);
         METRICS_REGISTRY.register("LockOwnerId", var0x -> var0x.threadInfo.getLockOwnerId(), Codec.LONG);
         METRICS_REGISTRY.register("LockOwnerName", var0x -> var0x.threadInfo.getLockOwnerName(), Codec.STRING);
         METRICS_REGISTRY.register(
            "StackTrace", var0x -> var0x.threadInfo.getStackTrace(), new ArrayCodec<>(STACK_TRACE_ELEMENT_METRICS_REGISTRY, StackTraceElement[]::new)
         );
         METRICS_REGISTRY.register(
            "InitStackTrace",
            var0x -> var0x.thread class="kw">instanceof InitStackThread ? ((InitStackThread)var0x.thread).getInitStack() : null,
            new ArrayCodec<>(STACK_TRACE_ELEMENT_METRICS_REGISTRY, StackTraceElement[]::new)
         );
         METRICS_REGISTRY.register("Interrupted", var0x -> var0x.thread != null ? var0x.thread.isInterrupted() : null, Codec.BOOLEAN);
         METRICS_REGISTRY.register("ThreadClass", var0x -> var0x.thread != null ? var0x.thread.getClass().getName() : null, Codec.STRING);
         MetricsRegistry var0 = new MetricsRegistry<>();
         var0.register("Name", ThreadGroup::getName, Codec.STRING);
         var0.register("Parent", ThreadGroup::getParent, var0);
         var0.register("MaxPriority", ThreadGroup::getMaxPriority, Codec.INTEGER);
         var0.register("Destroyed", ThreadGroup::isDestroyed, Codec.BOOLEAN);
         var0.register("Daemon", ThreadGroup::isDaemon, Codec.BOOLEAN);
         var0.register("ActiveCount", ThreadGroup::activeCount, Codec.INTEGER);
         var0.register("ActiveGroupCount", ThreadGroup::activeGroupCount, Codec.INTEGER);
         METRICS_REGISTRY.register("ThreadGroup", var0x -> var0x.thread != null ? var0x.thread.getThreadGroup() : null, var0);
         METRICS_REGISTRY.register(
            "UncaughtExceptionHandler", var0x -> var0x.thread != null ? var0x.thread.getUncaughtExceptionHandler().getClass().getName() : null, Codec.STRING
         );
      }
   }
}