/*
    *  Licensed to the Apache Software Foundation (ASF) under one
    *  or more contributor license agreements.  See the NOTICE file
    *  distributed with this work for additional information
    *  regarding copyright ownership.  The ASF 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 org.apache.mina.filter.compression;
  
  import java.io.IOException;
  
  import org.apache.mina.core.buffer.IoBuffer;
  import org.apache.mina.core.filterchain.IoFilter;
  import org.apache.mina.core.filterchain.IoFilterAdapter;
  import org.apache.mina.core.filterchain.IoFilterChain;
  import org.apache.mina.core.session.AttributeKey;
  import org.apache.mina.core.session.IoSession;
  import org.apache.mina.core.write.WriteRequest;
  
  /**
   * An {@link IoFilter} which compresses all data using
   * <a href="http://www.jcraft.com/jzlib/">JZlib</a>.
   * Support for the LZW (DLCZ) algorithm is also planned.
   * <p>
   * This filter only supports compression using the <tt>PARTIAL FLUSH</tt> method,
   * since that is the only method useful when doing stream level compression.
   * <p>
   * This filter supports compression/decompression of the input and output
   * channels selectively.  It can also be enabled/disabled on the fly.
   * <p>
   * This filter does not discard the zlib objects, keeping them around for the
   * entire life of the filter.  This is because the zlib dictionary needs to
   * be built up over time, which is used during compression and decompression.
   * Over time, as repetitive data is sent over the wire, the compression efficiency
   * steadily increases.
   * <p>
   * Note that the zlib header is written only once. It is not necessary that
   * the data received after processing by this filter may not be complete due
   * to packet fragmentation.
   * <p>
   * It goes without saying that the other end of this stream should also have a
   * compatible compressor/decompressor using the same algorithm.
   *
   * @author <a href="http://mina.apache.org">Apache MINA Project</a>
   */
  public class CompressionFilter extends IoFilterAdapter {
      /**
       * Max compression level.  Will give the highest compression ratio, but
       * will also take more cpu time and is the slowest.
       */
      public static final int COMPRESSION_MAX = Zlib.COMPRESSION_MAX;
  
      /**
       * Provides the best speed at the price of a low compression ratio.
       */
      public static final int COMPRESSION_MIN = Zlib.COMPRESSION_MIN;
  
      /**
       * No compression done on the data.
       */
      public static final int COMPRESSION_NONE = Zlib.COMPRESSION_NONE;
  
      /**
       * The default compression level used. Provides the best balance
       * between speed and compression
       */
      public static final int COMPRESSION_DEFAULT = Zlib.COMPRESSION_DEFAULT;
  
      /**
       * A session attribute that stores the {@link Zlib} object used for compression.
       */
      private final AttributeKeyibuteKey.html#AttributeKey">AttributeKey DEFLATER = new AttributeKey(getClass(), "deflater");
  
      /**
       * A session attribute that stores the {@link Zlib} object used for decompression.
       */
      private final AttributeKeyibuteKey.html#AttributeKey">AttributeKey INFLATER = new AttributeKey(getClass(), "inflater");
  
      /**
       * A flag that allows you to disable compression once.
       */
      public static final AttributeKeytributeKey">AttributeKey DISABLE_COMPRESSION_ONCE = new AttributeKey(CompressionFilter.class, "disableOnce");
  
      private boolean compressInbound = true;
  
      private boolean compressOutbound = true;
  
     private int compressionLevel;
 
     /**
      * Creates a new instance which compresses outboud data and decompresses
      * inbound data with default compression level.
      */
     public CompressionFilter() {
         this(true, true, COMPRESSION_DEFAULT);
     }
 
     /**
      * Creates a new instance which compresses outboud data and decompresses
      * inbound data with the specified <tt>compressionLevel</tt>.
      *
      * @param compressionLevel the level of compression to be used. Must
      *                         be one of {@link #COMPRESSION_DEFAULT},
      *                         {@link #COMPRESSION_MAX},
      *                         {@link #COMPRESSION_MIN}, and
      *                         {@link #COMPRESSION_NONE}.
      */
     public CompressionFilter(final int compressionLevel) {
         this(true, true, compressionLevel);
     }
 
     /**
      * Creates a new instance.
      *
      * @param compressInbound <tt>true</tt> if data read is to be decompressed
      * @param compressOutbound <tt>true</tt> if data written is to be compressed
      * @param compressionLevel the level of compression to be used. Must
      *                         be one of {@link #COMPRESSION_DEFAULT},
      *                         {@link #COMPRESSION_MAX},
      *                         {@link #COMPRESSION_MIN}, and
      *                         {@link #COMPRESSION_NONE}.
      */
     public CompressionFilter(final boolean compressInbound, final boolean compressOutbound, final int compressionLevel) {
         this.compressionLevel = compressionLevel;
         this.compressInbound = compressInbound;
         this.compressOutbound = compressOutbound;
     }
     
     /**
      * {@inheritDoc}
      */
     @Override
     public void filterWrite(NextFilter nextFilter, IoSession session, WriteRequest writeRequest) throws Exception {
         Object compressedMessage = doFilterWrite(nextFilter, session, writeRequest);
         
         if (compressedMessage != null && compressedMessage != writeRequest.getMessage()) {
             writeRequest.setMessage( compressedMessage );
         }
         
         nextFilter.filterWrite(session, writeRequest);
     }
 
     @Override
     public void messageReceived(NextFilter nextFilter, IoSession session, Object message) throws Exception {
         if (!compressInbound || !(message instanceof IoBuffer)) {
             nextFilter.messageReceived(session, message);
             return;
         }
 
         Zlib../../../../../org/apache/mina/filter/compression/Zlib.html#Zlib">Zlib inflater = (Zlib) session.getAttribute(INFLATER);
         
         if (inflater == null) {
             throw new IllegalStateException();
         }
 
         IoBuffer./../../../org/apache/mina/core/buffer/IoBuffer.html#IoBuffer">IoBuffer inBuffer = (IoBuffer) message;
         nextFilter.messageReceived(session, inflater.inflate(inBuffer));
     }
     
     /*
      * @see org.apache.mina.core.IoFilter#filterWrite(org.apache.mina.core.IoFilter.NextFilter, org.apache.mina.core.IoSession, org.apache.mina.core.IoFilter.WriteRequest)
      */
     protected Object doFilterWrite(NextFilter nextFilter, IoSession session, WriteRequest writeRequest)
             throws IOException {
         if (!compressOutbound) {
             return null;
         }
 
         if (session.containsAttribute(DISABLE_COMPRESSION_ONCE)) {
             // Remove the marker attribute because it is temporary.
             session.removeAttribute(DISABLE_COMPRESSION_ONCE);
             return null;
         }
 
         Zlib../../../../../org/apache/mina/filter/compression/Zlib.html#Zlib">Zlib deflater = (Zlib) session.getAttribute(DEFLATER);
         
         if (deflater == null) {
             throw new IllegalStateException();
         }
 
         IoBuffer./../../../org/apache/mina/core/buffer/IoBuffer.html#IoBuffer">IoBuffer inBuffer = (IoBuffer) writeRequest.getMessage();
         
         if (!inBuffer.hasRemaining()) {
             // Ignore empty buffers
             return null;
         } else {
             return deflater.deflate(inBuffer);
         }
     }
 
     @Override
     public void onPreAdd(IoFilterChain parent, String name, NextFilter nextFilter) throws Exception {
         if (parent.contains(CompressionFilter.class)) {
             throw new IllegalStateException("Only one " + CompressionFilter.class + " is permitted.");
         }
 
         Zlibmpression/Zlib.html#Zlib">Zlib deflater = new Zlib(compressionLevel, Zlib.MODE_DEFLATER);
         Zlibmpression/Zlib.html#Zlib">Zlib inflater = new Zlib(compressionLevel, Zlib.MODE_INFLATER);
 
         IoSession session = parent.getSession();
 
         session.setAttribute(DEFLATER, deflater);
         session.setAttribute(INFLATER, inflater);
     }
 
     /**
      * @return <tt>true</tt> if incoming data is being compressed.
      */
     public boolean isCompressInbound() {
         return compressInbound;
     }
 
     /**
      * Sets if incoming data has to be compressed.
      * 
      * @param compressInbound <tt>true</tt> if the incoming data has to be compressed
      */
     public void setCompressInbound(boolean compressInbound) {
         this.compressInbound = compressInbound;
     }
 
     /**
      * @return <tt>true</tt> if the filter is compressing data being written.
      */
     public boolean isCompressOutbound() {
         return compressOutbound;
     }
 
     /**
      * Set if outgoing data has to be compressed.
      * 
      * @param compressOutbound <tt>true</tt> if the outgoing data has to be compressed
      */
     public void setCompressOutbound(boolean compressOutbound) {
         this.compressOutbound = compressOutbound;
     }
 
     @Override
     public void onPostRemove(IoFilterChain parent, String name, NextFilter nextFilter) throws Exception {
         super.onPostRemove(parent, name, nextFilter);
         IoSession session = parent.getSession();
         if (session == null) {
             return;
         }
 
         Zlib../../../../../org/apache/mina/filter/compression/Zlib.html#Zlib">Zlib inflater = (Zlib) session.getAttribute(INFLATER);
         Zlib../../../../../org/apache/mina/filter/compression/Zlib.html#Zlib">Zlib deflater = (Zlib) session.getAttribute(DEFLATER);
         if (deflater != null) {
             deflater.cleanUp();
         }
 
         if (inflater != null) {
             inflater.cleanUp();
         }
     }
 }