/*
 * 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);
    }

}