/*
    * Copyright 2012 The Netty Project
    *
    * The Netty Project licenses this file to you under the Apache License,
    * version 2.0 (the "License"); you may not use this file except in compliance
    * with the License. You may obtain a copy of the License at:
    *
    *   http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations
   * under the License.
   */
  package io.netty.handler.codec.compression;
  
  import static io.netty.handler.codec.compression.Snappy.validateChecksum;
  import io.netty.buffer.ByteBuf;
  import io.netty.buffer.ByteBufUtil;
  import io.netty.channel.ChannelHandlerContext;
  import io.netty.handler.codec.ByteToMessageDecoder;
  
  import java.util.Arrays;
  import java.util.List;
  
  /**
   * Uncompresses a {@link ByteBuf} encoded with the Snappy framing format.
   *
   * See http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
   *
   * Note that by default, validation of the checksum header in each chunk is
   * DISABLED for performance improvements. If performance is less of an issue,
   * or if you would prefer the safety that checksum validation brings, please
   * use the {@link #SnappyFramedDecoder(boolean)} constructor with the argument
   * set to {@code true}.
   */
  public class SnappyFramedDecoder extends ByteToMessageDecoder {
  
      private enum ChunkType {
          STREAM_IDENTIFIER,
          COMPRESSED_DATA,
          UNCOMPRESSED_DATA,
          RESERVED_UNSKIPPABLE,
          RESERVED_SKIPPABLE
      }
  
      private static final byte[] SNAPPY = { 's', 'N', 'a', 'P', 'p', 'Y' };
      private static final int MAX_UNCOMPRESSED_DATA_SIZE = 65536 + 4;
  
      private final Snappy snappy = new Snappy();
      private final boolean validateChecksums;
  
      private boolean started;
      private boolean corrupted;
  
      /**
       * Creates a new snappy-framed decoder with validation of checksums
       * turned OFF. To turn checksum validation on, please use the alternate
       * {@link #SnappyFramedDecoder(boolean)} constructor.
       */
      public SnappyFramedDecoder() {
          this(false);
      }
  
      /**
       * Creates a new snappy-framed decoder with validation of checksums
       * as specified.
       *
       * @param validateChecksums
       *        If true, the checksum field will be validated against the actual
       *        uncompressed data, and if the checksums do not match, a suitable
       *        {@link DecompressionException} will be thrown
       */
      public SnappyFramedDecoder(boolean validateChecksums) {
          this.validateChecksums = validateChecksums;
      }
  
      @Override
      protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
          if (corrupted) {
              in.skipBytes(in.readableBytes());
              return;
          }
  
          try {
              int idx = in.readerIndex();
              final int inSize = in.readableBytes();
              if (inSize < 4) {
                  // We need to be at least able to read the chunk type identifier (one byte),
                  // and the length of the chunk (3 bytes) in order to proceed
                  return;
              }
  
              final int chunkTypeVal = in.getUnsignedByte(idx);
              final ChunkType chunkType = mapChunkType((byte) chunkTypeVal);
              final int chunkLength = ByteBufUtil.swapMedium(in.getUnsignedMedium(idx + 1));
  
              switch (chunkType) {
                 case STREAM_IDENTIFIER:
                     if (chunkLength != SNAPPY.length) {
                         throw new DecompressionException("Unexpected length of stream identifier: " + chunkLength);
                     }
 
                     if (inSize < 4 + SNAPPY.length) {
                         break;
                     }
 
                     byte[] identifier = new byte[chunkLength];
                     in.skipBytes(4).readBytes(identifier);
 
                     if (!Arrays.equals(identifier, SNAPPY)) {
                         throw new DecompressionException("Unexpected stream identifier contents. Mismatched snappy " +
                                 "protocol version?");
                     }
 
                     started = true;
                     break;
                 case RESERVED_SKIPPABLE:
                     if (!started) {
                         throw new DecompressionException("Received RESERVED_SKIPPABLE tag before STREAM_IDENTIFIER");
                     }
 
                     if (inSize < 4 + chunkLength) {
                         // TODO: Don't keep skippable bytes
                         return;
                     }
 
                     in.skipBytes(4 + chunkLength);
                     break;
                 case RESERVED_UNSKIPPABLE:
                     // The spec mandates that reserved unskippable chunks must immediately
                     // return an error, as we must assume that we cannot decode the stream
                     // correctly
                     throw new DecompressionException(
                             "Found reserved unskippable chunk type: 0x" + Integer.toHexString(chunkTypeVal));
                 case UNCOMPRESSED_DATA:
                     if (!started) {
                         throw new DecompressionException("Received UNCOMPRESSED_DATA tag before STREAM_IDENTIFIER");
                     }
                     if (chunkLength > MAX_UNCOMPRESSED_DATA_SIZE) {
                         throw new DecompressionException("Received UNCOMPRESSED_DATA larger than 65540 bytes");
                     }
 
                     if (inSize < 4 + chunkLength) {
                         return;
                     }
 
                     in.skipBytes(4);
                     if (validateChecksums) {
                         int checksum = ByteBufUtil.swapInt(in.readInt());
                         validateChecksum(checksum, in, in.readerIndex(), chunkLength - 4);
                     } else {
                         in.skipBytes(4);
                     }
                     out.add(in.readSlice(chunkLength - 4).retain());
                     break;
                 case COMPRESSED_DATA:
                     if (!started) {
                         throw new DecompressionException("Received COMPRESSED_DATA tag before STREAM_IDENTIFIER");
                     }
 
                     if (inSize < 4 + chunkLength) {
                         return;
                     }
 
                     in.skipBytes(4);
                     int checksum = ByteBufUtil.swapInt(in.readInt());
                     ByteBuf uncompressed = ctx.alloc().buffer(0);
                     if (validateChecksums) {
                         int oldWriterIndex = in.writerIndex();
                         try {
                             in.writerIndex(in.readerIndex() + chunkLength - 4);
                             snappy.decode(in, uncompressed);
                         } finally {
                             in.writerIndex(oldWriterIndex);
                         }
                         validateChecksum(checksum, uncompressed, 0, uncompressed.writerIndex());
                     } else {
                         snappy.decode(in.readSlice(chunkLength - 4), uncompressed);
                     }
                     out.add(uncompressed);
                     snappy.reset();
                     break;
             }
         } catch (Exception e) {
             corrupted = true;
             throw e;
         }
     }
 
     /**
      * Decodes the chunk type from the type tag byte.
      *
      * @param type The tag byte extracted from the stream
      * @return The appropriate {@link ChunkType}, defaulting to {@link ChunkType#RESERVED_UNSKIPPABLE}
      */
     private static ChunkType mapChunkType(byte type) {
         if (type == 0) {
             return ChunkType.COMPRESSED_DATA;
         } else if (type == 1) {
             return ChunkType.UNCOMPRESSED_DATA;
         } else if (type == (byte) 0xff) {
             return ChunkType.STREAM_IDENTIFIER;
         } else if ((type & 0x80) == 0x80) {
             return ChunkType.RESERVED_SKIPPABLE;
         } else {
             return ChunkType.RESERVED_UNSKIPPABLE;
         }
     }
 }