/*
    * 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.chemistry.opencmis.server.shared;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.FilterInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  
  /**
   * An OutputStream that stores the data in main memory until it reaches a
   * threshold. If the threshold is passed the data is written to a temporary
   * file.
   * 
   * It it is important to close this OutputStream before
   * {@link #getInputStream()} is called or call {@link #destroy()} if the
   * InputStream isn't required!
   */
  public class ThresholdOutputStream extends OutputStream {
      private static final int MAX_GROW = 10 * 1024 * 1024;
      private static final int DEFAULT_THRESHOLD = 4 * 1024 * 1024;
  
      private File tempDir;
      private int memoryThreshold;
  
      private byte[] buf = null;
      private int bufSize = 0;
      private long size;
      private File tempFile;
      private OutputStream tmpStream;
  
      public ThresholdOutputStream(File tempDir, int memoryThreshold) {
          this(64 * 1024, tempDir, memoryThreshold);
      }
  
      public ThresholdOutputStream(int initSize, File tempDir, int memoryThreshold) {
          if (initSize < 0) {
              throw new IllegalArgumentException("Negative initial size: " + initSize);
          }
  
          this.tempDir = tempDir;
          this.memoryThreshold = (memoryThreshold < 0 ? DEFAULT_THRESHOLD : memoryThreshold);
  
          buf = new byte[initSize];
      }
  
      private void expand(int nextBufferSize) throws IOException {
          if (bufSize + nextBufferSize <= buf.length) {
              return;
          }
  
          if (bufSize + nextBufferSize > memoryThreshold) {
              if (tmpStream == null) {
                  tempFile = File.createTempFile("opencmis", null, tempDir);
                  tmpStream = new BufferedOutputStream(new FileOutputStream(tempFile));
              }
              tmpStream.write(buf, 0, bufSize);
  
              if (buf.length != memoryThreshold) {
                  buf = new byte[memoryThreshold];
              }
              bufSize = 0;
  
              return;
          }
  
          int newSize = ((bufSize + nextBufferSize) * 2 < MAX_GROW ? (bufSize + nextBufferSize) * 2 : buf.length
                  + nextBufferSize + MAX_GROW);
          byte[] newbuf = new byte[newSize];
          System.arraycopy(buf, 0, newbuf, 0, bufSize);
          buf = newbuf;
      }
  
      public long getSize() {
          return size;
      }
  
     @Override
     public void write(byte[] buffer) throws IOException {
         write(buffer, 0, buffer.length);
     }
 
     @Override
     public void write(byte[] buffer, int offset, int len) throws IOException {
         if (len == 0) {
             return;
         }
 
         expand(len);
         System.arraycopy(buffer, offset, buf, bufSize, len);
         bufSize += len;
         size += len;
     }
 
     @Override
     public void write(int oneByte) throws IOException {
         if (bufSize == buf.length) {
             expand(1);
         }
 
         buf[bufSize++] = (byte) oneByte;
         size++;
     }
 
     @Override
     public void flush() throws IOException {
         if (tmpStream != null) {
             if (bufSize > 0) {
                 tmpStream.write(buf, 0, bufSize);
                 bufSize = 0;
             }
             tmpStream.flush();
         }
     }
 
     @Override
     public void close() throws IOException {
         flush();
 
         if (tmpStream != null) {
             tmpStream.close();
         }
     }
 
     /**
      * Destroys the object before it has been read.
      */
     public void destroy() {
         try {
             close();
         } catch (Exception e) {
             // ignore
         }
 
         if (tempFile != null) {
             tempFile.delete();
         }
 
         buf = null;
     }
 
     /**
      * Returns the data as an InputStream.
      */
     public InputStream getInputStream() throws Exception {
         if (tmpStream != null) {
             close();
             buf = null;
 
             return new InternalTempFileInputStream();
         } else {
             return new InternalBufferInputStream();
         }
     }
 
     /**
      * Provides information about the input stream.
      */
     public interface ThresholdInputStream {
 
         /**
          * Returns <code>true</code> if the data is in memory. Returns
          * <code>false</code> if the data resides in a temporary file.
          */
         boolean isInMemory();
 
         /**
          * Returns the temporary file if the data stored in a file. Returns
          * <code>null</code> is the data is stored in memory.
          */
         File getTemporaryFile();
     }
 
     /**
      * InputStream for in-memory data.
      */
     private class InternalBufferInputStream extends InputStream implements ThresholdInputStream {
 
         private int pos = 0;
 
         public boolean isInMemory() {
             return true;
         }
 
         public File getTemporaryFile() {
             return null;
         }
 
         @Override
         public boolean markSupported() {
             return false;
         }
 
         @Override
         public int available() {
             return bufSize - pos;
         }
 
         @Override
         public int read() {
             return (pos < bufSize) && (buf != null) ? (buf[pos++] & 0xff) : -1;
         }
 
         @Override
         public int read(byte[] b) throws IOException {
             return read(b, 0, b.length);
         }
 
         @Override
         public int read(byte[] b, int off, int len) {
             if ((pos >= bufSize) || (buf == null)) {
                 return -1;
             }
 
             if ((pos + len) > bufSize) {
                 len = (bufSize - pos);
             }
 
             System.arraycopy(buf, pos, b, off, len);
             pos += len;
 
             return len;
         }
 
         @Override
         public long skip(long n) {
             if ((pos + n) > bufSize) {
                 n = bufSize - pos;
             }
 
             if (n < 0) {
                 return 0;
             }
 
             pos += n;
 
             return n;
         }
 
         @Override
         public void close() throws IOException {
             buf = null;
         }
     }
 
     /**
      * InputStream for file data.
      */
     private class InternalTempFileInputStream extends FilterInputStream implements ThresholdInputStream {
 
         private boolean isDeleted = false;
 
         public InternalTempFileInputStream() throws FileNotFoundException {
             super(new BufferedInputStream(new FileInputStream(tempFile), memoryThreshold));
         }
 
         public boolean isInMemory() {
             return false;
         }
 
         public File getTemporaryFile() {
             return tempFile;
         }
 
         @Override
         public boolean markSupported() {
             return false;
         }
 
         @Override
         public int read() throws IOException {
             int b = super.read();
 
             if (b == -1 && !isDeleted) {
                 super.close();
                 isDeleted = tempFile.delete();
             }
 
             return b;
         }
 
         @Override
         public int read(byte[] b) throws IOException {
             return read(b, 0, b.length);
         }
 
         @Override
         public int read(byte[] b, int off, int len) throws IOException {
             int n = super.read(b, off, len);
 
             if (n == -1 && !isDeleted) {
                 super.close();
                 isDeleted = tempFile.delete();
             }
 
             return n;
         }
 
         @Override
         public void close() throws IOException {
             if (!isDeleted) {
                 super.close();
                 isDeleted = tempFile.delete();
             }
         }
     }
 }