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

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.metrics.MetricsRegistry;
class="kw">import com.hypixel.hytale.metrics.metric.AverageCollector;
class="kw">import com.hypixel.hytale.protocol.PacketRegistry;
class="kw">import com.hypixel.hytale.protocol.io.PacketStatsRecorder;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Queue;
class="kw">import java.util.concurrent.ConcurrentLinkedQueue;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.concurrent.atomic.AtomicInteger;
class="kw">import java.util.concurrent.atomic.AtomicLong;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class PacketStatsRecorderImpl class="kw">implements PacketStatsRecorder {
   class="kw">public class="kw">static class="kw">final MetricsRegistry<PacketStatsRecorderImpl> METRICS_REGISTRY = new MetricsRegistry<PacketStatsRecorderImpl>().register("Packets", var0 -> {
      ArrayList var1 = new ArrayList<>();

      for (int var2 = 0; var2 < 512; var2++) {
         PacketStatsRecorderImpl.PacketStatsEntry var3 = var0.entries[var2];
         if (var3.hasData()) {
            var1.add(var3);
         }
      }

      class="kw">return var1.toArray(PacketStatsRecorderImpl.PacketStatsEntry[]::new);
   }, new ArrayCodec<>(PacketStatsRecorderImpl.PacketStatsEntry.METRICS_REGISTRY, PacketStatsRecorderImpl.PacketStatsEntry[]::new));
   class="kw">private class="kw">final PacketStatsRecorderImpl.PacketStatsEntry[] entries = new PacketStatsRecorderImpl.PacketStatsEntry[512];

   class="kw">public PacketStatsRecorderImpl() {
      for (int var1 = 0; var1 < this.entries.length; var1++) {
         this.entries[var1] = new PacketStatsRecorderImpl.PacketStatsEntry(var1);
      }
   }

   @Override
   class="kw">public void recordSend(int var1, int var2, int var3) {
      if (var1 >= 0 && var1 < this.entries.length) {
         this.entries[var1].recordSend(var2, var3);
      }
   }

   @Override
   class="kw">public void recordReceive(int var1, int var2, int var3) {
      if (var1 >= 0 && var1 < this.entries.length) {
         this.entries[var1].recordReceive(var2, var3);
      }
   }

   @Nonnull
   class="kw">public PacketStatsRecorderImpl.PacketStatsEntry getEntry(int var1) {
      class="kw">return this.entries[var1];
   }

   class="kw">public class="kw">static class PacketStatsEntry class="kw">implements PacketStatsRecorder.PacketStatsEntry {
      class="kw">public class="kw">static class="kw">final MetricsRegistry<PacketStatsRecorderImpl.PacketStatsEntry> METRICS_REGISTRY = new MetricsRegistry<PacketStatsRecorderImpl.PacketStatsEntry>()
         .register("PacketId", PacketStatsRecorderImpl.PacketStatsEntry::getPacketId, Codec.INTEGER)
         .register("Name", PacketStatsRecorderImpl.PacketStatsEntry::getName, Codec.STRING)
         .register("SentCount", PacketStatsRecorderImpl.PacketStatsEntry::getSentCount, Codec.INTEGER)
         .register("SentUncompressedTotal", PacketStatsRecorderImpl.PacketStatsEntry::getSentUncompressedTotal, Codec.LONG)
         .register("SentCompressedTotal", PacketStatsRecorderImpl.PacketStatsEntry::getSentCompressedTotal, Codec.LONG)
         .register("SentUncompressedMin", PacketStatsRecorderImpl.PacketStatsEntry::getSentUncompressedMin, Codec.LONG)
         .register("SentUncompressedMax", PacketStatsRecorderImpl.PacketStatsEntry::getSentUncompressedMax, Codec.LONG)
         .register("SentCompressedMin", PacketStatsRecorderImpl.PacketStatsEntry::getSentCompressedMin, Codec.LONG)
         .register("SentCompressedMax", PacketStatsRecorderImpl.PacketStatsEntry::getSentCompressedMax, Codec.LONG)
         .register("ReceivedCount", PacketStatsRecorderImpl.PacketStatsEntry::getReceivedCount, Codec.INTEGER)
         .register("ReceivedUncompressedTotal", PacketStatsRecorderImpl.PacketStatsEntry::getReceivedUncompressedTotal, Codec.LONG)
         .register("ReceivedCompressedTotal", PacketStatsRecorderImpl.PacketStatsEntry::getReceivedCompressedTotal, Codec.LONG)
         .register("ReceivedUncompressedMin", PacketStatsRecorderImpl.PacketStatsEntry::getReceivedUncompressedMin, Codec.LONG)
         .register("ReceivedUncompressedMax", PacketStatsRecorderImpl.PacketStatsEntry::getReceivedUncompressedMax, Codec.LONG)
         .register("ReceivedCompressedMin", PacketStatsRecorderImpl.PacketStatsEntry::getReceivedCompressedMin, Codec.LONG)
         .register("ReceivedCompressedMax", PacketStatsRecorderImpl.PacketStatsEntry::getReceivedCompressedMax, Codec.LONG);
      class="kw">private class="kw">final int packetId;
      class="kw">private class="kw">final AtomicInteger sentCount = new AtomicInteger();
      class="kw">private class="kw">final AtomicLong sentUncompressedTotal = new AtomicLong();
      class="kw">private class="kw">final AtomicLong sentCompressedTotal = new AtomicLong();
      class="kw">private class="kw">final AtomicLong sentUncompressedMin = new AtomicLong(Long.MAX_VALUE);
      class="kw">private class="kw">final AtomicLong sentUncompressedMax = new AtomicLong();
      class="kw">private class="kw">final AtomicLong sentCompressedMin = new AtomicLong(Long.MAX_VALUE);
      class="kw">private class="kw">final AtomicLong sentCompressedMax = new AtomicLong();
      class="kw">private class="kw">final AverageCollector sentUncompressedAvg = new AverageCollector();
      class="kw">private class="kw">final AverageCollector sentCompressedAvg = new AverageCollector();
      class="kw">private class="kw">final Queue<PacketStatsRecorderImpl.PacketStatsEntry.SizeRecord> sentRecently = new ConcurrentLinkedQueue<>();
      class="kw">private class="kw">final AtomicInteger receivedCount = new AtomicInteger();
      class="kw">private class="kw">final AtomicLong receivedUncompressedTotal = new AtomicLong();
      class="kw">private class="kw">final AtomicLong receivedCompressedTotal = new AtomicLong();
      class="kw">private class="kw">final AtomicLong receivedUncompressedMin = new AtomicLong(Long.MAX_VALUE);
      class="kw">private class="kw">final AtomicLong receivedUncompressedMax = new AtomicLong();
      class="kw">private class="kw">final AtomicLong receivedCompressedMin = new AtomicLong(Long.MAX_VALUE);
      class="kw">private class="kw">final AtomicLong receivedCompressedMax = new AtomicLong();
      class="kw">private class="kw">final AverageCollector receivedUncompressedAvg = new AverageCollector();
      class="kw">private class="kw">final AverageCollector receivedCompressedAvg = new AverageCollector();
      class="kw">private class="kw">final Queue<PacketStatsRecorderImpl.PacketStatsEntry.SizeRecord> receivedRecently = new ConcurrentLinkedQueue<>();

      class="kw">public PacketStatsEntry(int var1) {
         this.packetId = var1;
      }

      void recordSend(int var1, int var2) {
         this.sentCount.incrementAndGet();
         this.sentUncompressedTotal.addAndGet(var1);
         this.sentCompressedTotal.addAndGet(var2);
         this.sentUncompressedMin.accumulateAndGet(var1, Math::min);
         this.sentUncompressedMax.accumulateAndGet(var1, Math::max);
         this.sentCompressedMin.accumulateAndGet(var2, Math::min);
         this.sentCompressedMax.accumulateAndGet(var2, Math::max);
         this.sentUncompressedAvg.add(var1);
         this.sentCompressedAvg.add(var2);
         long var3 = System.nanoTime();
         this.sentRecently.add(new PacketStatsRecorderImpl.PacketStatsEntry.SizeRecord(var3, var1, var2));
         this.pruneOld(this.sentRecently, var3);
      }

      void recordReceive(int var1, int var2) {
         this.receivedCount.incrementAndGet();
         this.receivedUncompressedTotal.addAndGet(var1);
         this.receivedCompressedTotal.addAndGet(var2);
         this.receivedUncompressedMin.accumulateAndGet(var1, Math::min);
         this.receivedUncompressedMax.accumulateAndGet(var1, Math::max);
         this.receivedCompressedMin.accumulateAndGet(var2, Math::min);
         this.receivedCompressedMax.accumulateAndGet(var2, Math::max);
         this.receivedUncompressedAvg.add(var1);
         this.receivedCompressedAvg.add(var2);
         long var3 = System.nanoTime();
         this.receivedRecently.add(new PacketStatsRecorderImpl.PacketStatsEntry.SizeRecord(var3, var1, var2));
         this.pruneOld(this.receivedRecently, var3);
      }

      class="kw">private void pruneOld(Queue<PacketStatsRecorderImpl.PacketStatsEntry.SizeRecord> var1, long var2) {
         long var4 = var2 - TimeUnit.SECONDS.toNanos(30L);

         for (PacketStatsRecorderImpl.PacketStatsEntry.SizeRecord var6 = var1.peek(); var6 != null && var6.nanos < var4; var6 = var1.peek()) {
            var1.poll();
         }
      }

      @Override
      class="kw">public boolean hasData() {
         class="kw">return this.sentCount.get() > 0 || this.receivedCount.get() > 0;
      }

      @Override
      class="kw">public int getPacketId() {
         class="kw">return this.packetId;
      }

      @Nullable
      @Override
      class="kw">public String getName() {
         PacketRegistry.PacketInfo var1 = PacketRegistry.all().get(this.packetId);
         class="kw">return var1 != null ? var1.name() : null;
      }

      @Override
      class="kw">public int getSentCount() {
         class="kw">return this.sentCount.get();
      }

      @Override
      class="kw">public long getSentUncompressedTotal() {
         class="kw">return this.sentUncompressedTotal.get();
      }

      @Override
      class="kw">public long getSentCompressedTotal() {
         class="kw">return this.sentCompressedTotal.get();
      }

      @Override
      class="kw">public long getSentUncompressedMin() {
         class="kw">return this.sentCount.get() > 0 ? this.sentUncompressedMin.get() : 0L;
      }

      @Override
      class="kw">public long getSentUncompressedMax() {
         class="kw">return this.sentUncompressedMax.get();
      }

      @Override
      class="kw">public long getSentCompressedMin() {
         class="kw">return this.sentCount.get() > 0 ? this.sentCompressedMin.get() : 0L;
      }

      @Override
      class="kw">public long getSentCompressedMax() {
         class="kw">return this.sentCompressedMax.get();
      }

      @Override
      class="kw">public double getSentUncompressedAvg() {
         class="kw">return this.sentUncompressedAvg.get();
      }

      @Override
      class="kw">public double getSentCompressedAvg() {
         class="kw">return this.sentCompressedAvg.get();
      }

      @Override
      class="kw">public int getReceivedCount() {
         class="kw">return this.receivedCount.get();
      }

      @Override
      class="kw">public long getReceivedUncompressedTotal() {
         class="kw">return this.receivedUncompressedTotal.get();
      }

      @Override
      class="kw">public long getReceivedCompressedTotal() {
         class="kw">return this.receivedCompressedTotal.get();
      }

      @Override
      class="kw">public long getReceivedUncompressedMin() {
         class="kw">return this.receivedCount.get() > 0 ? this.receivedUncompressedMin.get() : 0L;
      }

      @Override
      class="kw">public long getReceivedUncompressedMax() {
         class="kw">return this.receivedUncompressedMax.get();
      }

      @Override
      class="kw">public long getReceivedCompressedMin() {
         class="kw">return this.receivedCount.get() > 0 ? this.receivedCompressedMin.get() : 0L;
      }

      @Override
      class="kw">public long getReceivedCompressedMax() {
         class="kw">return this.receivedCompressedMax.get();
      }

      @Override
      class="kw">public double getReceivedUncompressedAvg() {
         class="kw">return this.receivedUncompressedAvg.get();
      }

      @Override
      class="kw">public double getReceivedCompressedAvg() {
         class="kw">return this.receivedCompressedAvg.get();
      }

      @Nonnull
      @Override
      class="kw">public PacketStatsRecorder.RecentStats getSentRecently() {
         class="kw">return this.computeRecentStats(this.sentRecently);
      }

      @Nonnull
      @Override
      class="kw">public PacketStatsRecorder.RecentStats getReceivedRecently() {
         class="kw">return this.computeRecentStats(this.receivedRecently);
      }

      class="kw">private PacketStatsRecorder.RecentStats computeRecentStats(Queue<PacketStatsRecorderImpl.PacketStatsEntry.SizeRecord> var1) {
         int var2 = 0;
         long var3 = 0L;
         long var5 = 0L;
         int var7 = Integer.MAX_VALUE;
         int var8 = 0;
         int var9 = Integer.MAX_VALUE;
         int var10 = 0;

         for (PacketStatsRecorderImpl.PacketStatsEntry.SizeRecord var12 : var1) {
            var2++;
            var3 += var12.uncompressedSize;
            var5 += var12.compressedSize;
            var7 = Math.min(var7, var12.uncompressedSize);
            var8 = Math.max(var8, var12.uncompressedSize);
            var9 = Math.min(var9, var12.compressedSize);
            var10 = Math.max(var10, var12.compressedSize);
         }

         class="kw">return var2 == 0 ? PacketStatsRecorder.RecentStats.EMPTY : new PacketStatsRecorder.RecentStats(var2, var3, var5, var7, var8, var9, var10);
      }

      class="kw">public void reset() {
         this.sentCount.set(0);
         this.sentUncompressedTotal.set(0L);
         this.sentCompressedTotal.set(0L);
         this.sentUncompressedMin.set(Long.MAX_VALUE);
         this.sentUncompressedMax.set(0L);
         this.sentCompressedMin.set(Long.MAX_VALUE);
         this.sentCompressedMax.set(0L);
         this.sentUncompressedAvg.clear();
         this.sentCompressedAvg.clear();
         this.sentRecently.clear();
         this.receivedCount.set(0);
         this.receivedUncompressedTotal.set(0L);
         this.receivedCompressedTotal.set(0L);
         this.receivedUncompressedMin.set(Long.MAX_VALUE);
         this.receivedUncompressedMax.set(0L);
         this.receivedCompressedMin.set(Long.MAX_VALUE);
         this.receivedCompressedMax.set(0L);
         this.receivedUncompressedAvg.clear();
         this.receivedCompressedAvg.clear();
         this.receivedRecently.clear();
      }

      class="kw">public record SizeRecord(long nanos, int uncompressedSize, int compressedSize) {
         class="kw">public SizeRecord {
         }
      }
   }
}