/*
    * 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.any23.util;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.Reader;
  
  /**
   * Adapts a <code>Reader</code> as an <code>InputStream</code>. Adapted from <CODE>StringInputStream</CODE>.
   *
   */
  public class ReaderInputStream extends InputStream {
  
      /** Source Reader */
      private Reader in;
  
      private String encoding = System.getProperty("file.encoding");
  
      private byte[] slack;
  
      private int begin;
  
      /**
       * Construct a <CODE>ReaderInputStream</CODE> for the specified <CODE>Reader</CODE>.
       *
       * @param reader
       *            <CODE>Reader</CODE>. Must not be <code>null</code>.
       */
      public ReaderInputStream(Reader reader) {
          in = reader;
      }
  
      /**
       * Construct a <CODE>ReaderInputStream</CODE> for the specified <CODE>Reader</CODE>, with the specified encoding.
       *
       * @param reader
       *            non-null <CODE>Reader</CODE>.
       * @param encoding
       *            non-null <CODE>String</CODE> encoding.
       */
      public ReaderInputStream(Reader reader, String encoding) {
          this(reader);
          if (encoding == null) {
              throw new IllegalArgumentException("encoding must not be null");
          } else {
              this.encoding = encoding;
          }
      }
  
      /**
       * Reads from the <CODE>Reader</CODE>, returning the same value.
       *
       * @return the value of the next character in the <CODE>Reader</CODE>.
       *
       * @exception IOException
       *                if the original <code>Reader</code> fails to be read
       */
      public synchronized int read() throws IOException {
          if (in == null) {
              throw new IOException("Stream Closed");
          }
  
          byte result;
          if (slack != null && begin < slack.length) {
              result = slack[begin];
              if (++begin == slack.length) {
                  slack = null;
              }
          } else {
              byte[] buf = new byte[1];
              if (read(buf, 0, 1) <= 0) {
                  result = -1;
              }
              result = buf[0];
          }
  
          if (result < -1) {
              result += 256;
          }
  
          return result;
      }
  
     /**
      * Reads from the <code>Reader</code> into a byte array
      *
      * @param b
      *            the byte array to read into
      * @param off
      *            the offset in the byte array
      * @param len
      *            the length in the byte array to fill
      * 
      * @return the actual number read into the byte array, -1 at the end of the stream
      * 
      * @exception IOException
      *                if an error occurs
      */
     public synchronized int read(byte[] b, int off, int len) throws IOException {
         if (in == null) {
             throw new IOException("Stream Closed");
         }
 
         while (slack == null) {
             char[] buf = new char[len]; // might read too much
             int n = in.read(buf);
             if (n == -1) {
                 return -1;
             }
             if (n > 0) {
                 slack = new String(buf, 0, n).getBytes(encoding);
                 begin = 0;
             }
         }
 
         if (len > slack.length - begin) {
             len = slack.length - begin;
         }
 
         System.arraycopy(slack, begin, b, off, len);
 
         if ((begin += len) >= slack.length) {
             slack = null;
         }
 
         return len;
     }
 
     /**
      * Marks the read limit of the StringReader.
      *
      * @param limit
      *            the maximum limit of bytes that can be read before the mark position becomes invalid
      */
     public synchronized void mark(final int limit) {
         try {
             in.mark(limit);
         } catch (IOException ioe) {
             throw new RuntimeException(ioe.getMessage());
         }
     }
 
     /**
      * @return the current number of bytes ready for reading
      * 
      * @exception IOException
      *                if an error occurs
      */
     public synchronized int available() throws IOException {
         if (in == null) {
             throw new IOException("Stream Closed");
         }
         if (slack != null) {
             return slack.length - begin;
         }
         if (in.ready()) {
             return 1;
         } else {
             return 0;
         }
     }
 
     /**
      * @return false - mark is not supported
      */
     public boolean markSupported() {
         return false; // would be imprecise
     }
 
     /**
      * Resets the StringReader.
      *
      * @exception IOException
      *                if the StringReader fails to be reset
      */
     public synchronized void reset() throws IOException {
         if (in == null) {
             throw new IOException("Stream Closed");
         }
         slack = null;
         in.reset();
     }
 
     /**
      * Closes the Stringreader.
      *
      * @exception IOException
      *                if the original StringReader fails to be closed
      */
     public synchronized void close() throws IOException {
         if (in != null) {
             in.close();
             slack = null;
             in = null;
         }
     }
 }