/*
    * 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
    *
    *      https://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.codec.binary;
  
  import static org.junit.jupiter.api.Assertions.assertArrayEquals;
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertNotNull;
  import static org.junit.jupiter.api.Assertions.assertThrows;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  
  import java.io.ByteArrayInputStream;
  import java.io.InputStream;
  
  import org.apache.commons.io.IOUtils;
  import org.junit.jupiter.api.Test;
  
  /**
   * Tests {@link Base45InputStream}.
   */
  class Base45InputStreamTest {
  
      private static final byte[] CRLF = { (byte) '\r', (byte) '\n' };
      private static final byte[] LF = { (byte) '\n' };
      private static final String STRING_FIXTURE = "Hello World";
  
      @Test
      void testAvailable() throws Throwable {
          final String encoded = new String(new Base45().encode(StringUtils.getBytesUtf8("foo")));
          final InputStream ins = new ByteArrayInputStream(StringUtils.getBytesIso8859_1(encoded));
          try (Base45InputStream b45stream = new Base45InputStream(ins)) {
              final int initialAvailable = b45stream.available();
              assertTrue(initialAvailable > 0, "Initial available should be greater than 0");
              assertEquals(3, b45stream.skip(10), "Skip should return 3 (decoded bytes)");
              assertEquals(0, b45stream.available());
              assertEquals(-1, b45stream.read());
              assertEquals(-1, b45stream.read());
          }
      }
  
      private void testBase45EmptyInputStream(final int chunkSize) throws Exception {
          final byte[] emptyEncoded = {};
          final byte[] emptyDecoded = {};
          testByChunk(emptyEncoded, emptyDecoded, chunkSize, CRLF);
          testByteByByte(emptyEncoded, emptyDecoded, chunkSize, CRLF);
      }
  
      /**
       * Tests the Base45InputStream implementation against empty input.
       *
       * @throws Exception Thrown for some failure scenarios.
       */
      @Test
      void testBase45EmptyInputStreamMimeChunkSize() throws Exception {
          testBase45EmptyInputStream(BaseNCodec.MIME_CHUNK_SIZE);
      }
  
      /**
       * Tests the Base45InputStream implementation against empty input.
       *
       * @throws Exception Thrown for some failure scenarios.
       */
      @Test
      void testBase45EmptyInputStreamPemChunkSize() throws Exception {
          testBase45EmptyInputStream(BaseNCodec.PEM_CHUNK_SIZE);
      }
  
      @Test
      void testBase45InputStreamByChunk() throws Exception {
          // Hello World test.
          byte[] decoded = StringUtils.getBytesUtf8(STRING_FIXTURE);
          byte[] encoded = new Base45().encode(decoded);
          testByChunk(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
          // test random data of sizes 0 through 150
          final BaseNCodec codec = new Base45();
          for (int i = 0; i <= 150; i++) {
              final byte[][] randomData = BaseNTestData.randomData(codec, i);
              encoded = randomData[1];
              decoded = randomData[0];
              testByChunk(encoded, decoded, 0, LF);
          }
      }
  
      @Test
     void testBase45InputStreamByteByByte() throws Exception {
         // Hello World test.
         byte[] decoded = StringUtils.getBytesUtf8(STRING_FIXTURE);
         byte[] encoded = new Base45().encode(decoded);
         testByteByByte(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
         // test random data of sizes 0 through 150
         final BaseNCodec codec = new Base45();
         for (int i = 0; i <= 150; i++) {
             final byte[][] randomData = BaseNTestData.randomData(codec, i);
             encoded = randomData[1];
             decoded = randomData[0];
             testByteByByte(encoded, decoded, 0, LF);
         }
     }
 
     @Test
     void testBuilder() {
         assertNotNull(Base45InputStream.builder().getBaseNCodec());
     }
 
     /**
      * Tests method does three tests on the supplied data: 1. encoded ---[DECODE]--> decoded 2. decoded ---[ENCODE]--> encoded 3. decoded
      * ---[WRAP-WRAP-WRAP-etc...] --> decoded
      * <p/>
      * By "[WRAP-WRAP-WRAP-etc...]" we mean situation where the Base45InputStream wraps itself in encode and decode mode over and over again.
      *
      * @param encoded   Base45 encoded data
      * @param decoded   The data from above, but decoded
      * @param chunkSize chunk size (line-length) of the Base45 encoded data.
      * @param separator Line separator in the Base45 encoded data.
      * @throws Exception Thrown if a bug occurs in the Base45 commons-codec implementation.
      */
     private void testByChunk(final byte[] encoded, final byte[] decoded, final int chunkSize, final byte[] separator) throws Exception {
         try (InputStream in = Base45InputStream.builder().setByteArray(decoded).setEncode(true).get()) {
             final byte[] output = IOUtils.toByteArray(in);
             assertEquals(-1, in.read(), "EOF");
             assertEquals(-1, in.read(), "Still EOF");
             assertArrayEquals(encoded, output, "Streaming Base45 encode");
         }
         try (InputStream in = new Base45InputStream(new ByteArrayInputStream(encoded))) {
             final byte[] output = IOUtils.toByteArray(in);
             assertEquals(-1, in.read(), "EOF");
             assertEquals(-1, in.read(), "Still EOF");
             assertArrayEquals(decoded, output, "Streaming Base45 decode");
         }
         InputStream in = new ByteArrayInputStream(decoded);
         for (int i = 0; i < 10; i++) {
             in = Base45InputStream.builder().setInputStream(in).setEncode(true).get();
             in = Base45InputStream.builder().setInputStream(in).setEncode(false).get();
         }
         final InputStream in1 = in;
         final byte[] output = IOUtils.toByteArray(in1);
         assertEquals(-1, in.read(), "EOF");
         assertEquals(-1, in.read(), "Still EOF");
         assertArrayEquals(decoded, output, "Streaming Base45 wrap-wrap-wrap!");
         in.close();
     }
 
     /**
      * Tests method does three tests on the supplied data: 1. encoded ---[DECODE]--> decoded 2. decoded ---[ENCODE]--> encoded 3. decoded
      * ---[WRAP-WRAP-WRAP-etc...] --> decoded
      * <p/>
      * By "[WRAP-WRAP-WRAP-etc...]" we mean situation where the Base45InputStream wraps itself in encode and decode mode over and over again.
      *
      * @param encoded   Base45 encoded data
      * @param decoded   The data from above, but decoded
      * @param chunkSize chunk size (line-length) of the Base45 encoded data.
      * @param separator Line separator in the Base45 encoded data.
      * @throws Exception Thrown if a bug occurs in the Base45 commons-codec implementation.
      */
     private void testByteByByte(final byte[] encoded, final byte[] decoded, final int chunkSize, final byte[] separator) throws Exception {
         InputStream in;
         in = Base45InputStream.builder().setByteArray(decoded).setEncode(true).get();
         final InputStream in1 = in;
         byte[] output = IOUtils.toByteArray(in1);
         assertEquals(-1, in.read(), "EOF");
         assertEquals(-1, in.read(), "Still EOF");
         assertArrayEquals(encoded, output, "Streaming Base45 encode");
         in.close();
         in = new Base45InputStream(new ByteArrayInputStream(encoded));
         final InputStream in2 = in;
         output = IOUtils.toByteArray(in2);
         assertEquals(-1, in.read(), "EOF");
         assertEquals(-1, in.read(), "Still EOF");
         assertArrayEquals(decoded, output, "Streaming Base45 decode");
         in.close();
         in = new ByteArrayInputStream(decoded);
         for (int i = 0; i < 10; i++) {
             in = Base45InputStream.builder().setInputStream(in).setEncode(true).get();
             in = Base45InputStream.builder().setInputStream(in).setEncode(false).get();
         }
         final InputStream in3 = in;
         output = IOUtils.toByteArray(in3);
         assertEquals(-1, in.read(), "EOF");
         assertEquals(-1, in.read(), "Still EOF");
         assertArrayEquals(decoded, output, "Streaming Base45 wrap-wrap-wrap!");
     }
 
     /**
      * Tests markSupported.
      *
      * @throws Exception Thrown for some failure scenarios.
      */
     @Test
     void testMarkSupported() throws Exception {
         final byte[] decoded = StringUtils.getBytesUtf8(STRING_FIXTURE);
         try (Base45InputStream in = Base45InputStream.builder().setByteArray(decoded).setEncode(true).get()) {
             // Always returns false for now.
             assertFalse(in.markSupported(), "Base45InputStream.markSupported() is false");
         }
     }
 
     /**
      * Tests read returning 0
      *
      * @throws Exception Thrown for some failure scenarios.
      */
     @Test
     void testRead0() throws Exception {
         final byte[] decoded = StringUtils.getBytesUtf8(STRING_FIXTURE);
         final byte[] buf = new byte[1024];
         int bytesRead = 0;
         try (Base45InputStream in = Base45InputStream.builder().setByteArray(decoded).setEncode(true).get()) {
             bytesRead = in.read(buf, 0, 0);
             assertEquals(0, bytesRead, "Base45InputStream.read(buf, 0, 0) returns 0");
         }
     }
 
     /**
      * Tests read with null.
      *
      * @throws Exception Thrown for some failure scenarios.
      */
     @Test
     void testReadNull() throws Exception {
         final byte[] decoded = StringUtils.getBytesUtf8(STRING_FIXTURE);
         try (Base45InputStream in = Base45InputStream.builder().setByteArray(decoded).setEncode(true).get()) {
             assertThrows(NullPointerException.class, () -> in.read(null, 0, 0));
         }
     }
 
     /**
      * Tests read throwing IndexOutOfBoundsException
      *
      * @throws Exception Thrown for some failure scenarios.
      */
     @Test
     void testReadOutOfBounds() throws Exception {
         final byte[] decoded = StringUtils.getBytesUtf8(STRING_FIXTURE);
         final byte[] buf = new byte[1024];
         try (Base45InputStream in = Base45InputStream.builder().setByteArray(decoded).setEncode(true).get()) {
             assertThrows(IndexOutOfBoundsException.class, () -> in.read(buf, -1, 0), "Base45InputStream.read(buf, -1, 0)");
             assertThrows(IndexOutOfBoundsException.class, () -> in.read(buf, 0, -1), "Base45InputStream.read(buf, 0, -1)");
             assertThrows(IndexOutOfBoundsException.class, () -> in.read(buf, buf.length + 1, 0), "Base45InputStream.read(buf, buf.length + 1, 0)");
             assertThrows(IndexOutOfBoundsException.class, () -> in.read(buf, buf.length - 1, 2), "Base45InputStream.read(buf, buf.length - 1, 2)");
         }
     }
 
     /**
      * Tests skipping number of characters larger than the internal buffer.
      *
      * @throws Throwable Thrown for some failure scenarios.
      */
     @Test
     void testSkipBig() throws Throwable {
         final String encoded = new String(new Base45().encode(StringUtils.getBytesUtf8("foo")));
         final InputStream ins = new ByteArrayInputStream(StringUtils.getBytesIso8859_1(encoded));
         try (Base45InputStream b45stream = new Base45InputStream(ins)) {
             assertEquals(3, b45stream.skip(1024));
             // End of stream reached
             assertEquals(-1, b45stream.read());
             assertEquals(-1, b45stream.read());
         }
     }
 
     /**
      * Tests skipping as a noop
      *
      * @throws Throwable Thrown for some failure scenarios.
      */
     @Test
     void testSkipNone() throws Throwable {
         final String encoded = new String(new Base45().encode(StringUtils.getBytesUtf8("foo")));
         final InputStream ins = new ByteArrayInputStream(StringUtils.getBytesIso8859_1(encoded));
         try (Base45InputStream b45stream = new Base45InputStream(ins)) {
             final byte[] actualBytes = new byte[3];
             assertEquals(0, b45stream.skip(0));
             b45stream.read(actualBytes, 0, actualBytes.length);
             assertArrayEquals(actualBytes, new byte[] { 102, 111, 111 });
             // End of stream reached
             assertEquals(-1, b45stream.read());
         }
     }
 
     /**
      * Tests skipping past the end of a stream.
      *
      * @throws Throwable Thrown for some failure scenarios.
      */
     @Test
     void testSkipPastEnd() throws Throwable {
         final String encoded = new String(new Base45().encode(StringUtils.getBytesUtf8("foo")));
         final InputStream ins = new ByteArrayInputStream(StringUtils.getBytesIso8859_1(encoded));
         try (Base45InputStream b45stream = new Base45InputStream(ins)) {
             // skip correctly decoded characters
             assertEquals(3, b45stream.skip(10));
             // End of stream reached
             assertEquals(-1, b45stream.read());
             assertEquals(-1, b45stream.read());
         }
     }
 
     /**
      * Tests skipping to the end of a stream.
      *
      * @throws Throwable Thrown for some failure scenarios.
      */
     @Test
     void testSkipToEnd() throws Throwable {
         final String encoded = new String(new Base45().encode(StringUtils.getBytesUtf8("foo")));
         final InputStream ins = new ByteArrayInputStream(StringUtils.getBytesIso8859_1(encoded));
         try (Base45InputStream b45stream = new Base45InputStream(ins)) {
             // skip correctly decoded characters
             assertEquals(3, b45stream.skip(3));
             assertEquals(-1, b45stream.read());
         }
     }
 
     /**
      * Tests if negative arguments to skip are handled correctly.
      *
      * @throws Throwable Thrown for some failure scenarios.
      */
     @Test
     void testSkipWrongArgument() throws Throwable {
         final String encoded = new String(new Base45().encode(StringUtils.getBytesUtf8("foo")));
         final InputStream ins = new ByteArrayInputStream(StringUtils.getBytesIso8859_1(encoded));
         try (Base45InputStream b45stream = new Base45InputStream(ins)) {
             assertThrows(IllegalArgumentException.class, () -> b45stream.skip(-1));
         }
     }
 }