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

class="kw">import com.hypixel.hytale.protocol.NetworkChannel;
class="kw">import com.hypixel.hytale.protocol.PacketRegistry;
class="kw">import com.hypixel.hytale.protocol.io.PacketIO;
class="kw">import com.hypixel.hytale.protocol.io.PacketStatsRecorder;
class="kw">import com.hypixel.hytale.protocol.io.ProtocolException;
class="kw">import io.netty.buffer.ByteBuf;
class="kw">import io.netty.buffer.Unpooled;
class="kw">import io.netty.channel.Channel;
class="kw">import io.netty.channel.ChannelHandlerContext;
class="kw">import io.netty.handler.codec.ByteToMessageDecoder;
class="kw">import io.netty.handler.codec.quic.QuicChannel;
class="kw">import io.netty.handler.codec.quic.QuicTransportError;
class="kw">import io.netty.handler.timeout.ReadTimeoutException;
class="kw">import java.time.Duration;
class="kw">import java.util.List;
class="kw">import java.util.concurrent.ScheduledFuture;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import javax.annotation.Nonnull;

class="kw">public class PacketDecoder class="kw">extends ByteToMessageDecoder {
   class="kw">private class="kw">static class="kw">final int LENGTH_PREFIX_SIZE = 4;
   class="kw">private class="kw">static class="kw">final int PACKET_ID_SIZE = 4;
   class="kw">private class="kw">static class="kw">final int MIN_FRAME_SIZE = 8;
   class="kw">private class="kw">static class="kw">final long CHECK_INTERVAL_MS = 1000L;
   class="kw">private class="kw">volatile long lastPacketTimeNanos;
   class="kw">private ScheduledFuture<?> timeoutCheckFuture;

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

   class="kw">public void handlerAdded(@Nonnull ChannelHandlerContext var1) class="kw">throws Exception {
      if (var1.channel().isActive()) {
         this.initialize(var1);
      }

      super.handlerAdded(var1);
   }

   class="kw">public void channelActive(@Nonnull ChannelHandlerContext var1) class="kw">throws Exception {
      this.initialize(var1);
      super.channelActive(var1);
   }

   class="kw">public void channelInactive(@Nonnull ChannelHandlerContext var1) class="kw">throws Exception {
      this.cancelTimeoutCheck();
      super.channelInactive(var1);
   }

   class="kw">private void initialize(@Nonnull ChannelHandlerContext var1) {
      if (this.timeoutCheckFuture == null) {
         this.lastPacketTimeNanos = System.nanoTime();
         this.timeoutCheckFuture = var1.executor().scheduleAtFixedRate(() -> this.checkTimeout(var1), 1000L, 1000L, TimeUnit.MILLISECONDS);
      }
   }

   class="kw">private void cancelTimeoutCheck() {
      if (this.timeoutCheckFuture != null) {
         this.timeoutCheckFuture.cancel(false);
         this.timeoutCheckFuture = null;
      }
   }

   class="kw">private void checkTimeout(@Nonnull ChannelHandlerContext var1) {
      if (!var1.channel().isActive()) {
         this.cancelTimeoutCheck();
      } else {
         Duration var2 = (Duration)var1.channel().attr(ProtocolUtil.PACKET_TIMEOUT_KEY).get();
         if (var2 != null) {
            long var3 = System.nanoTime() - this.lastPacketTimeNanos;
            if (var3 >= var2.toNanos()) {
               this.cancelTimeoutCheck();
               var1.fireExceptionCaught(ReadTimeoutException.INSTANCE);
               var1.close();
            }
         }
      }
   }

   class="kw">protected void decode(@Nonnull ChannelHandlerContext var1, @Nonnull ByteBuf var2, @Nonnull List<Object> var3) {
      if (var2.readableBytes() >= 8) {
         var2.markReaderIndex();
         int var4 = var2.readIntLE();
         if (var4 >= 0 && var4 <= 1677721600) {
            int var5 = var2.readIntLE();
            PacketRegistry.PacketInfo var6 = PacketRegistry.getToServerPacketById(var5);
            if (var6 == null) {
               var2.skipBytes(var2.readableBytes());
               closeConnection(var1.channel());
            } else if (var4 > var6.maxSize()) {
               var2.skipBytes(var2.readableBytes());
               closeConnection(var1.channel());
            } else {
               NetworkChannel var7 = (NetworkChannel)var1.channel().attr(ProtocolUtil.STREAM_CHANNEL_KEY).get();
               if (var7 != null && var7 != var6.channel()) {
                  var2.skipBytes(var2.readableBytes());
                  closeConnection(var1.channel());
               } else if (var2.readableBytes() < var4) {
                  var2.resetReaderIndex();
               } else {
                  PacketStatsRecorder var8 = (PacketStatsRecorder)var1.channel().attr(PacketStatsRecorder.CHANNEL_KEY).get();
                  if (var8 == null) {
                     var8 = PacketStatsRecorder.NOOP;
                  }

                  try {
                     var3.add(PacketIO.readFramedPacketWithInfo(var2, var4, var1.alloc(), var6, var8));
                     this.lastPacketTimeNanos = System.nanoTime();
                  } catch (ProtocolException var10) {
                     var2.skipBytes(var2.readableBytes());
                     closeConnection(var1.channel());
                  } catch (IndexOutOfBoundsException var11) {
                     var2.skipBytes(var2.readableBytes());
                     closeConnection(var1.channel());
                  }
               }
            }
         } else {
            var2.skipBytes(var2.readableBytes());
            closeConnection(var1.channel());
         }
      }
   }

   class="kw">private class="kw">static void closeConnection(@Nonnull Channel var0) {
      int var1 = (int)QuicTransportError.PROTOCOL_VIOLATION.code();
      if (var0 class="kw">instanceof QuicChannel var2) {
         var2.close(false, var1, Unpooled.EMPTY_BUFFER);
      } else if (var0.parent() class="kw">instanceof QuicChannel var3) {
         var3.close(false, var1, Unpooled.EMPTY_BUFFER);
      } else {
         var0.close();
      }
   }
}