/*
    * 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.commons.flatfile.util;
  
  import java.io.IOException;
  import java.io.InputStream;
  
  import org.apache.commons.lang3.Validate;
  
  /**
   * Provides factory methods to return InputStreams that return a repeating
   * ordered sequence of bytes, optionally limiting output to some maximum total
   * size.
   *
   * @version $Revision: 1301242 $ $Date: 2009-03-24 16:09:19 -0500 (Tue, 24 Mar
   *          2009) $
   */
  public abstract class RepeatingInputStream {
      /**
       * Construct a new {@link RepeatingInputStream} instance.
       */
      private RepeatingInputStream() {
      }
  
      /**
       * An InputStream that repeats a single byte forever.
       */
      private static class RepeatOneByte extends InputStream {
          private final byte b;
  
          /**
           * Create a new RepeatOneByte instance.
           *
           * @param b byte to repeat
           */
          private RepeatOneByte(byte b) {
              this.b = b;
          }
  
          /**
           * {@inheritDoc}
           */
          public int read() throws IOException {
              return b;
          }
      }
  
      /**
       * An InputStream that repeats a byte[] forever.
       */
      private static class RepeatArray extends InputStream {
          private final byte[] b;
          private int pos;
  
          /**
           * Create a new RepeatArray instance.
           *
           * @param b byte[] to repeat
           */
          private RepeatArray(byte[] b) {
              this.b = b;
          }
  
          /**
           * {@inheritDoc}
           */
          public synchronized int read() throws IOException {
              try {
                  return b[pos++];
              } finally {
                  if (pos == b.length) {
                      pos = 0;
                  }
              }
          }
      }
  
      /**
       * InputStream that limits the content of another InputStream.
       */
      private static class LimitedOutput extends InputStream {
          private static final int EOF = -1;
  
          private final InputStream source;
          private final int bytesToReturn;
         private int bytesReturned;
 
         /**
          * Create a new LimitedOutput instance.
          *
          * @param source wrapped InputStream
          * @param bytesToReturn int max
          */
         private LimitedOutput(InputStream source, int bytesToReturn) {
             this.source = source;
             this.bytesToReturn = bytesToReturn;
         }
 
         /**
          * {@inheritDoc}
          */
         public int read() throws IOException {
             if (bytesReturned == bytesToReturn) {
                 return EOF;
             }
             try {
                 return source.read();
             } finally {
                 bytesReturned++;
             }
         }
     }
 
     /**
      * Holds cached instances of single-byte RepeatingInputStreams, with enough
      * space for every unique byte value.
      */
     private static final InputStream[] REPEAT_BYTE = new InputStream[(int) Math.pow(2, Byte.SIZE)];
 
     /**
      * Get an InputStream that will return the specified byte[] forever.
      *
      * @param b byte[] to repeat
      * @return {@link InputStream}
      * @throws NullPointerException if {@code b} is {@code null}
      */
     public static InputStream of(byte... b) {
         Validate.notNull(b);
         if (b.length == 1) {
             final int index = 0 | b[0];
             InputStream result = REPEAT_BYTE[index];
             if (result == null) {
                 result = new RepeatOneByte(b[0]);
                 REPEAT_BYTE[index] = result;
             }
             return result;
         }
         return new RepeatArray(b);
     }
 
     /**
      * Get an InputStream that will return the specified byte sequence until a
      * total of {@code limit} bytes have been returned.
      *
      * @param limit int
      * @param b byte[] to repeat
      * @return {@link InputStream}
      * @throws NullPointerException if {@code b} is {@code null}
      */
     public static synchronized InputStream withLimit(int limit, byte... b) {
         return new LimitedOutput(of(b), limit);
     }
 
 }