/*
    * 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.compress.utils;
  
  import java.io.Closeable;
  import java.io.IOException;
  import java.io.InputStream;
  import java.nio.ByteOrder;
  
  /**
   * Reads bits from an InputStream.
   *
   * @since 1.10
   * @NotThreadSafe
   */
  public class BitInputStream implements Closeable {
      private static final int MAXIMUM_CACHE_SIZE = 63; // bits in long minus sign bit
      private static final long[] MASKS = new long[MAXIMUM_CACHE_SIZE + 1];
  
      static {
          for (int i = 1; i <= MAXIMUM_CACHE_SIZE; i++) {
              MASKS[i] = (MASKS[i - 1] << 1) + 1;
          }
      }
  
      private final org.apache.commons.io.input.BoundedInputStream in;
      private final ByteOrder byteOrder;
      private long bitsCached;
      private int bitsCachedSize;
  
      /**
       * Constructor taking an InputStream and its bit arrangement.
       *
       * @param in        the InputStream
       * @param byteOrder the bit arrangement across byte boundaries, either BIG_ENDIAN (aaaaabbb bb000000) or LITTLE_ENDIAN (bbbaaaaa 000000bb)
       */
      public BitInputStream(final InputStream in, final ByteOrder byteOrder) {
          this.in = org.apache.commons.io.input.BoundedInputStream.builder().setInputStream(in).asSupplier().get();
          this.byteOrder = byteOrder;
      }
  
      /**
       * Drops bits until the next bits will be read from a byte boundary.
       *
       * @since 1.16
       */
      public void alignWithByteBoundary() {
          final int toSkip = bitsCachedSize % Byte.SIZE;
          if (toSkip > 0) {
              readCachedBits(toSkip);
          }
      }
  
      /**
       * Returns an estimate of the number of bits that can be read from this input stream without blocking by the next invocation of a method for this input
       * stream.
       *
       * @throws IOException if the underlying stream throws one when calling available
       * @return estimate of the number of bits that can be read without blocking
       * @since 1.16
       */
      public long bitsAvailable() throws IOException {
          return bitsCachedSize + (long) Byte.SIZE * in.available();
      }
  
      /**
       * Returns the number of bits that can be read from this input stream without reading from the underlying input stream at all.
       *
       * @return estimate of the number of bits that can be read without reading from the underlying stream
       * @since 1.16
       */
      public int bitsCached() {
          return bitsCachedSize;
      }
  
      /**
       * Clears the cache of bits that have been read from the underlying stream but not yet provided via {@link #readBits}.
       */
      public void clearBitCache() {
          bitsCached = 0;
          bitsCachedSize = 0;
      }
  
     @Override
     public void close() throws IOException {
         in.close();
     }
 
     /**
      * Fills the cache up to 56 bits
      *
      * @param count
      * @return return true, when EOF
      * @throws IOException
      */
     private boolean ensureCache(final int count) throws IOException {
         while (bitsCachedSize < count && bitsCachedSize < 57) {
             final long nextByte = in.read();
             if (nextByte < 0) {
                 return true;
             }
             if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
                 bitsCached |= nextByte << bitsCachedSize;
             } else {
                 bitsCached <<= Byte.SIZE;
                 bitsCached |= nextByte;
             }
             bitsCachedSize += Byte.SIZE;
         }
         return false;
     }
 
     /**
      * Returns the number of bytes read from the underlying stream.
      * <p>
      * This includes the bytes read to fill the current cache and not read as bits so far.
      * </p>
      *
      * @return the number of bytes read from the underlying stream
      * @since 1.17
      */
     public long getBytesRead() {
         return in.getCount();
     }
 
     private long processBitsGreater57(final int count) throws IOException {
         final long bitsOut;
         final int overflowBits;
         long overflow = 0L;
 
         // bitsCachedSize >= 57 and left-shifting it 8 bits would cause an overflow
         final int bitsToAddCount = count - bitsCachedSize;
         overflowBits = Byte.SIZE - bitsToAddCount;
         final long nextByte = in.read();
         if (nextByte < 0) {
             return nextByte;
         }
         if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
             final long bitsToAdd = nextByte & MASKS[bitsToAddCount];
             bitsCached |= bitsToAdd << bitsCachedSize;
             overflow = nextByte >>> bitsToAddCount & MASKS[overflowBits];
         } else {
             bitsCached <<= bitsToAddCount;
             final long bitsToAdd = nextByte >>> overflowBits & MASKS[bitsToAddCount];
             bitsCached |= bitsToAdd;
             overflow = nextByte & MASKS[overflowBits];
         }
         bitsOut = bitsCached & MASKS[count];
         bitsCached = overflow;
         bitsCachedSize = overflowBits;
         return bitsOut;
     }
 
     /**
      * Returns at most 63 bits read from the underlying stream.
      *
      * @param count the number of bits to read, must be a positive number not bigger than 63.
      * @return the bits concatenated as a long using the stream's byte order. -1 if the end of the underlying stream has been reached before reading the
      *         requested number of bits
      * @throws IOException on error
      */
     public long readBits(final int count) throws IOException {
         if (count < 0 || count > MAXIMUM_CACHE_SIZE) {
             throw new IOException("count must not be negative or greater than " + MAXIMUM_CACHE_SIZE);
         }
         if (ensureCache(count)) {
             return -1;
         }
 
         if (bitsCachedSize < count) {
             return processBitsGreater57(count);
         }
         return readCachedBits(count);
     }
 
     private long readCachedBits(final int count) {
         final long bitsOut;
         if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
             bitsOut = bitsCached & MASKS[count];
             bitsCached >>>= count;
         } else {
             bitsOut = bitsCached >> bitsCachedSize - count & MASKS[count];
         }
         bitsCachedSize -= count;
         return bitsOut;
     }
 
 }