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

class="kw">import com.hypixel.hytale.protocol.io.PacketIO;
class="kw">import io.netty.buffer.ByteBuf;
class="kw">import io.netty.buffer.Unpooled;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import javax.annotation.Nonnull;

class="kw">public class="kw">final class CachedPacket<T class="kw">extends ToClientPacket> class="kw">implements ToClientPacket, AutoCloseable {
   class="kw">private class="kw">final Class<T> packetType;
   class="kw">private class="kw">final int packetId;
   class="kw">private class="kw">final NetworkChannel packetChannel;
   class="kw">private class="kw">final ByteBuf cachedBytes;

   class="kw">private CachedPacket(Class<T> var1, int var2, NetworkChannel var3, ByteBuf var4) {
      this.packetType = var1;
      this.packetId = var2;
      this.packetChannel = var3;
      this.cachedBytes = var4;
   }

   class="kw">public class="kw">static <T class="kw">extends ToClientPacket> CachedPacket<T> cache(@Nonnull T var0) {
      if (var0 class="kw">instanceof CachedPacket) {
         throw new IllegalArgumentException("Cannot cache a CachedPacket");
      }

      byte[] var1 = new byte[var0.computeSize()];
      var0.serialize(MemorySegment.ofArray(var1), 0);
      ByteBuf var2 = Unpooled.wrappedBuffer(var1);
      class="kw">return new CachedPacket<>((Class<T>)var0.getClass(), var0.getId(), var0.getChannel(), var2);
   }

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

   @Override
   class="kw">public NetworkChannel getChannel() {
      class="kw">return this.packetChannel;
   }

   @Override
   class="kw">public int serialize(@Nonnull MemorySegment var1, int var2) {
      this.requireNotReleased();
      MemorySegment.copy(this.cachedBytes.array(), this.cachedBytes.arrayOffset(), var1, PacketIO.PROTO_BYTE, var2, this.cachedBytes.readableBytes());
      class="kw">return this.cachedBytes.readableBytes();
   }

   @Override
   class="kw">public int computeSize() {
      this.requireNotReleased();
      class="kw">return this.cachedBytes.readableBytes();
   }

   class="kw">private void requireNotReleased() {
      if (this.cachedBytes.refCnt() <= 0) {
         throw new IllegalStateException("CachedPacket buffer was released before serialization completed");
      }
   }

   class="kw">public Class<T> getPacketType() {
      class="kw">return this.packetType;
   }

   class="kw">public int getCachedSize() {
      class="kw">return this.cachedBytes.readableBytes();
   }

   @Override
   class="kw">public void close() {
      if (this.cachedBytes.refCnt() > 0) {
         this.cachedBytes.release();
      }
   }
}