// Copyright 2015 Google Inc. All rights reserved.
//
// Licensed 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 com.google.archivepatcher.shared;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;

/**
 * Implementation of {@link Uncompressor} based on Java's built-in {@link Inflater}. Uses no-wrap by
 * default along with a 32k read buffer and a 32k write buffer. Buffers are allocated on-demand and
 * discarded after use. {@link Inflater} instances, which may be expensive, are also created
 * on-demand; This can be changed by using {@link #setCaching(boolean)}.
 */
public class DeflateUncompressor implements Uncompressor {
  /**
   * Whether to skip the standard zlib header and checksum fields when
   * reading. Defaults to true.
   */
  private boolean nowrap = true;

  /**
   * The size of the buffer used for reading data in during
   * {@link #uncompress(InputStream, OutputStream)}.
   */
  private int inputBufferSize = 32768;

  /**
   * The size of the buffer used for writing data out during
   * {@link #uncompress(InputStream, OutputStream)}.
   */
  private int outputBufferSize = 32768;

  /**
   * Cached {@link Inflater} to be used.
   */
  private Inflater inflater = null;

  /**
   * Whether or not to cache {@link Inflater} instances, which is a major performance tradeoff.
   */
  private boolean caching = false;

  /**
   * Returns whether to skip the standard zlib header and checksum fields when reading.
   * @return the value
   * @see Inflater#Inflater(boolean)
   */
  public boolean isNowrap() {
    return nowrap;
  }

  /**
   * Returns the size of the buffer used for reading from the input stream in
   * {@link #uncompress(InputStream, OutputStream)}.
   * @return the size (default is 32768)
   */
  public int getInputBufferSize() {
    return inputBufferSize;
  }

  /**
   * Sets the size of the buffer used for reading from the input stream in
   * {@link #uncompress(InputStream, OutputStream)}.
   * NB: {@link Inflater} uses an <em>internal</em> buffer and this method adjusts the size of that
   * buffer. This buffer is important for performance, <em>even if the {@link InputStream} is
   * is already buffered</em>.
   * @param inputBufferSize the size to set (default is 32768)
   */
  public void setInputBufferSize(int inputBufferSize) {
    this.inputBufferSize = inputBufferSize;
  }

  /**
   * Returns the size of the buffer used for writing to the output stream in
   * {@link #uncompress(InputStream, OutputStream)}.
   * @return the size (default is 32768)
   */
  public int getOutputBufferSize() {
    return outputBufferSize;
  }

  /**
   * Sets the size of the buffer used for writing to the output stream in
   * {@link #uncompress(InputStream, OutputStream)}.
   * @param outputBufferSize the size to set (default is 32768)
   */
  public void setOutputBufferSize(int outputBufferSize) {
    this.outputBufferSize = outputBufferSize;
  }

  /**
   * Sets whether or not to suppress wrapping the deflate output with the standard zlib header and
   * checksum fields. Defaults to false.
   * @param nowrap see {@link Inflater#Inflater(boolean)}
   */
  public void setNowrap(boolean nowrap) {
    if (nowrap != this.nowrap) {
      release(); // Cannot re-use the inflater any more.
      this.nowrap = nowrap;
    }
  }

  /**
   * Returns if caching is enabled.
   * @return true if enabled, otherwise false
   * @see #setCaching(boolean)
   */
  public boolean isCaching() {
    return caching;
  }

  /**
   * Sets whether or not to cache the {@link Inflater} instance. Defaults to false. If set to true,
   * the {@link Inflater} is kept until this object is finalized or until {@link #release()} is
   * called. Instances of {@link Inflater} can be surprisingly expensive, so caching is advised in
   * situations where many resources need to be inflated.
   * @param caching whether to enable caching
   */
  public void setCaching(boolean caching) {
    this.caching = caching;
  }

  /**
   * Returns the {@link Inflater} to be used, creating a new one if necessary and caching it for
   * future use.
   * @return the inflater
   */
  protected Inflater createOrResetInflater() {
    Inflater result = inflater;
    if (result == null) {
      result = new Inflater(nowrap);
      if (caching) {
        inflater = result;
      }
    } else {
      result.reset();
    }
    return result;
  }

  /**
   * Immediately releases any cached {@link Inflater} instance.
   */
  public void release() {
    if (inflater != null) {
      inflater.end();
      inflater = null;
    }
  }

  @Override
  public void uncompress(InputStream compressedIn, OutputStream uncompressedOut)
      throws IOException {
    InflaterInputStream inflaterIn =
        new InflaterInputStream(compressedIn, createOrResetInflater(), inputBufferSize);
    byte[] buffer = new byte[outputBufferSize];
    int numRead = 0;
    while ((numRead = inflaterIn.read(buffer)) >= 0) {
      uncompressedOut.write(buffer, 0, numRead);
    }
    if (!isCaching()) {
      release();
    }
  }
}