// 
// Decompiled by Procyon v0.6.0
// 

package org.bouncycastle.mime.encoding;

import java.io.IOException;
import java.io.EOFException;
import java.io.InputStream;

public class Base64InputStream extends InputStream
{
    private static final byte[] decodingTable;
    InputStream in;
    int[] outBuf;
    int bufPtr;
    
    private int decode(final int n, final int n2, final int n3, final int n4, final int[] array) throws EOFException {
        if (n4 < 0) {
            throw new EOFException("unexpected end of file in armored stream.");
        }
        if (n3 == 61) {
            array[2] = (((Base64InputStream.decodingTable[n] & 0xFF) << 2 | (Base64InputStream.decodingTable[n2] & 0xFF) >> 4) & 0xFF);
            return 2;
        }
        if (n4 == 61) {
            final byte b = Base64InputStream.decodingTable[n];
            final byte b2 = Base64InputStream.decodingTable[n2];
            final byte b3 = Base64InputStream.decodingTable[n3];
            array[1] = ((b << 2 | b2 >> 4) & 0xFF);
            array[2] = ((b2 << 4 | b3 >> 2) & 0xFF);
            return 1;
        }
        final byte b4 = Base64InputStream.decodingTable[n];
        final byte b5 = Base64InputStream.decodingTable[n2];
        final byte b6 = Base64InputStream.decodingTable[n3];
        final byte b7 = Base64InputStream.decodingTable[n4];
        array[0] = ((b4 << 2 | b5 >> 4) & 0xFF);
        array[1] = ((b5 << 4 | b6 >> 2) & 0xFF);
        array[2] = ((b6 << 6 | b7) & 0xFF);
        return 0;
    }
    
    public Base64InputStream(final InputStream in) {
        this.outBuf = new int[3];
        this.bufPtr = 3;
        this.in = in;
    }
    
    @Override
    public int available() throws IOException {
        return 0;
    }
    
    @Override
    public int read() throws IOException {
        if (this.bufPtr > 2) {
            final int ignoreSpaceFirst = this.readIgnoreSpaceFirst();
            if (ignoreSpaceFirst < 0) {
                return -1;
            }
            this.bufPtr = this.decode(ignoreSpaceFirst, this.readIgnoreSpace(), this.readIgnoreSpace(), this.readIgnoreSpace(), this.outBuf);
        }
        return this.outBuf[this.bufPtr++];
    }
    
    @Override
    public void close() throws IOException {
        this.in.close();
    }
    
    private int readIgnoreSpace() throws IOException {
        while (true) {
            final int read;
            switch (read = this.in.read()) {
                case 9:
                case 32: {
                    continue;
                }
                default: {
                    return read;
                }
            }
        }
    }
    
    private int readIgnoreSpaceFirst() throws IOException {
        while (true) {
            final int read;
            switch (read = this.in.read()) {
                case 9:
                case 10:
                case 13:
                case 32: {
                    continue;
                }
                default: {
                    return read;
                }
            }
        }
    }
    
    static {
        decodingTable = new byte[128];
        for (int i = 65; i <= 90; ++i) {
            Base64InputStream.decodingTable[i] = (byte)(i - 65);
        }
        for (int j = 97; j <= 122; ++j) {
            Base64InputStream.decodingTable[j] = (byte)(j - 97 + 26);
        }
        for (int k = 48; k <= 57; ++k) {
            Base64InputStream.decodingTable[k] = (byte)(k - 48 + 52);
        }
        Base64InputStream.decodingTable[43] = 62;
        Base64InputStream.decodingTable[47] = 63;
    }
}