/* 
 * 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 java.util.zip;


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

import org.apache.harmony.archive.internal.nls.Messages;

/**
 * The {@code GZIPInputStream} class is used to read data stored in the GZIP
 * format, reading and decompressing GZIP data from the underlying stream into
 * its buffer.
 * 
 * @since Android 1.0
 */
public class GZIPInputStream extends java.util.zip.InflaterInputStream {

    /**
     * The checksum algorithm used when handling uncompressed data.
     * 
     * @since Android 1.0
     */
    protected CRC32 crc = new CRC32();

    /**
     * Indicates the end of the input stream.
     * 
     * @since Android 1.0
     */
    protected boolean eos = false;

    /**
     * The magic header for the GZIP format.
     * 
     * @since Android 1.0
     */
    public final static int GZIP_MAGIC = 0x8b1f;

    private static final int FHCRC = 2;

    private static final int FEXTRA = 4;

    private static final int FNAME = 8;

    private static final int FCOMMENT = 16;

    /**
     * Construct a {@code GZIPInputStream} to read from GZIP data from the
     * underlying stream.
     * 
     * @param is
     *            the {@code InputStream} to read data from.
     * @throws IOException
     *             if an {@code IOException} occurs.
     * @since Android 1.0
     */
    public GZIPInputStream(InputStream is) throws IOException {
        this(is, BUF_SIZE);
    }

    /**
     * Construct a {@code GZIPInputStream} to read from GZIP data from the
     * underlying stream. Set the internal buffer size to {@code size}.
     * 
     * @param is
     *            the {@code InputStream} to read data from.
     * @param size
     *            the internal read buffer size.
     * @throws IOException
     *             if an {@code IOException} occurs.
     * @since Android 1.0
     */
    public GZIPInputStream(InputStream is, int size) throws IOException {
        super(is, new Inflater(true), size);
        byte[] header = new byte[10];
        readFully(header, 0, header.length);
        if (getShort(header, 0) != GZIP_MAGIC) {
            throw new IOException(Messages.getString("archive.1F")); //$NON-NLS-1$;
        }
        int flags = header[3];
        boolean hcrc = (flags & FHCRC) != 0;
        if (hcrc) {
            crc.update(header, 0, header.length);
        }
        if ((flags & FEXTRA) != 0) {
            readFully(header, 0, 2);
            if (hcrc) {
                crc.update(header, 0, 2);
            }
            int length = getShort(header, 0);
            while (length > 0) {
                int max = length > buf.length ? buf.length : length;
                int result = in.read(buf, 0, max);
                if (result == -1) {
                    throw new EOFException();
                }
                if (hcrc) {
                    crc.update(buf, 0, result);
                }
                length -= result;
            }
        }
        if ((flags & FNAME) != 0) {
            readZeroTerminated(hcrc);
        }
        if ((flags & FCOMMENT) != 0) {
            readZeroTerminated(hcrc);
        }
        if (hcrc) {
            readFully(header, 0, 2);
            int crc16 = getShort(header, 0);
            if ((crc.getValue() & 0xffff) != crc16) {
                throw new IOException(Messages.getString("archive.20")); //$NON-NLS-1$
            }
            crc.reset();
        }
    }

    private long getLong(byte[] buffer, int off) {
        long l = 0;
        l |= (buffer[off] & 0xFF);
        l |= (buffer[off + 1] & 0xFF) << 8;
        l |= (buffer[off + 2] & 0xFF) << 16;
        l |= ((long) (buffer[off + 3] & 0xFF)) << 24;
        return l;
    }

    private int getShort(byte[] buffer, int off) {
        return (buffer[off] & 0xFF) | ((buffer[off + 1] & 0xFF) << 8);
    }

    @Override
    public int read(byte[] buffer, int off, int nbytes) throws IOException {
        if (closed) {
            throw new IOException(Messages.getString("archive.1E")); //$NON-NLS-1$
        }
        if(eof){
            return -1;
        }
        // avoid int overflow, check null buffer
        if (off <= buffer.length && nbytes >= 0 && off >= 0
                && buffer.length - off >= nbytes) {
            int val = super.read(buffer, off, nbytes);
            if (val != -1) {
                crc.update(buffer, off, val);
            } else if (!eos) {
                eos = true;
                // Get non-compressed bytes read by fill
                // BEGIN android-changed
                // copied from newer version of harmony
                int size = inf.getRemaining();
                final int trailerSize = 8; // crc (4 bytes) + total out (4
                                            // bytes)
                byte[] b = new byte[trailerSize];
                int copySize = (size > trailerSize) ? trailerSize : size;

                System.arraycopy(buf, len - size, b, 0, copySize);
                readFully(b, copySize, trailerSize - copySize);                
                // END android-changed
                if (getLong(b, 0) != crc.getValue()) {
                    throw new IOException(Messages.getString("archive.20")); //$NON-NLS-1$
                }
                if ((int) getLong(b, 4) != inf.getTotalOut()) {
                    throw new IOException(Messages.getString("archive.21")); //$NON-NLS-1$
                }
            }
            return val;
        }
        throw new ArrayIndexOutOfBoundsException();
    }
    
    @Override
    public void close() throws IOException {
        eos = true;
        super.close();
    }

    private void readFully(byte[] buffer, int offset, int length)
            throws IOException {
        int result;
        while (length > 0) {
            result = in.read(buffer, offset, length);
            if (result == -1) {
                throw new EOFException();
            }
            offset += result;
            length -= result;
        }
    }

    private void readZeroTerminated(boolean hcrc) throws IOException {
        int result;
        while ((result = in.read()) > 0) {
            if (hcrc) {
                crc.update(result);
            }
        }
        if (result == -1) {
            throw new EOFException();
        }
        // Add the zero
        if (hcrc) {
            crc.update(result);
        }
    }
}