package net.sf.logdistiller.util;

/*
 * @(#)UncompressInputStream.java           0.3-3 06/05/2001
 *
 *  This file is part of the HTTPClient package
 *  Copyright (C) 1996-2001 Ronald Tschal�r
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA 02111-1307, USA
 *
 *  For questions, suggestions, bug-reports, enhancement-requests etc.
 *  I may be contacted at:
 *
 *  ronald@innovation.ch
 *
 *  The HTTPClient's home page is located at:
 *
 *  http://www.innovation.ch/java/HTTPClient/
 *
 */

//package HTTPClient;
import java.io.IOException;
import java.io.EOFException;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FilterInputStream;

/**
 * This class decompresses an input stream containing data compressed with the unix "compress" utility (LZC, a LZW
 * variant). This code is based heavily on the <var>unlzw.c</var> code in <var>gzip-1.2.4</var> (written by Peter
 * Jannesen) and the original compress code.
 *
 * @version 0.3-3 06/05/2001
 * @author Ronald Tschal�r
 */
public class UncompressInputStream
    extends FilterInputStream
{
    /**
     * @param is the input stream to decompress
     * @exception IOException if the header is malformed
     */
    public UncompressInputStream( InputStream is )
        throws IOException
    {
        super( is );
        parse_header();
    }

    byte[] one = new byte[1];

    public synchronized int read()
        throws IOException
    {
        int b = in.read( one, 0, 1 );
        if ( b == 1 )
            return ( one[0] & 0xff );
        else
            return -1;
    }

    // string table stuff
    private static final int TBL_CLEAR = 0x100;

    private static final int TBL_FIRST = TBL_CLEAR + 1;

    private int[] tab_prefix;

    private byte[] tab_suffix;

    private int[] zeros = new int[256];

    private byte[] stack;

    // various state
    private boolean block_mode;

    private int n_bits;

    private int maxbits;

    private int maxmaxcode;

    private int maxcode;

    private int bitmask;

    private int oldcode;

    private byte finchar;

    private int stackp;

    private int free_ent;

    // input buffer
    private byte[] data = new byte[10000];

    private int bit_pos = 0, end = 0, got = 0;

    private boolean eof = false;

    private static final int EXTRA = 64;

    public synchronized int read( byte[] buf, int off, int len )
        throws IOException
    {
        if ( eof )
            return -1;
        int start = off;

        /*
         * Using local copies of various variables speeds things up by as much as 30% !
         */
        int[] l_tab_prefix = tab_prefix;
        byte[] l_tab_suffix = tab_suffix;
        byte[] l_stack = stack;
        int l_n_bits = n_bits;
        int l_maxcode = maxcode;
        int l_maxmaxcode = maxmaxcode;
        int l_bitmask = bitmask;
        int l_oldcode = oldcode;
        byte l_finchar = finchar;
        int l_stackp = stackp;
        int l_free_ent = free_ent;
        byte[] l_data = data;
        int l_bit_pos = bit_pos;

        // empty stack if stuff still left

        int s_size = l_stack.length - l_stackp;
        if ( s_size > 0 )
        {
            int num = ( s_size >= len ) ? len : s_size;
            System.arraycopy( l_stack, l_stackp, buf, off, num );
            off += num;
            len -= num;
            l_stackp += num;
        }

        if ( len == 0 )
        {
            stackp = l_stackp;
            return off - start;
        }

        // loop, filling local buffer until enough data has been decompressed

        main_loop: do
        {
            if ( end < EXTRA )
                fill();

            int bit_in = ( got > 0 ) ? ( end - end % l_n_bits ) << 3 : ( end << 3 ) - ( l_n_bits - 1 );

            while ( l_bit_pos < bit_in )
            {
                // check for code-width expansion

                if ( l_free_ent > l_maxcode )
                {
                    int n_bytes = l_n_bits << 3;
                    l_bit_pos = ( l_bit_pos - 1 ) + n_bytes - ( l_bit_pos - 1 + n_bytes ) % n_bytes;

                    l_n_bits++;
                    l_maxcode = ( l_n_bits == maxbits ) ? l_maxmaxcode : ( 1 << l_n_bits ) - 1;

                    if ( debug )
                        System.err.println( "Code-width expanded to " + l_n_bits );

                    l_bitmask = ( 1 << l_n_bits ) - 1;
                    l_bit_pos = resetbuf( l_bit_pos );
                    continue main_loop;
                }

                // read next code

                int pos = l_bit_pos >> 3;
                int code =
                    ( ( ( l_data[pos] & 0xFF ) | ( ( l_data[pos + 1] & 0xFF ) << 8 ) | ( ( l_data[pos + 2] & 0xFF ) << 16 ) ) >> ( l_bit_pos & 0x7 ) )
                        & l_bitmask;
                l_bit_pos += l_n_bits;

                // handle first iteration

                if ( l_oldcode == -1 )
                {
                    if ( code >= 256 )
                        throw new IOException( "corrupt input: " + code + " > 255" );
                    l_finchar = (byte) ( l_oldcode = code );
                    buf[off++] = l_finchar;
                    len--;
                    continue;
                }

                // handle CLEAR code

                if ( code == TBL_CLEAR && block_mode )
                {
                    System.arraycopy( zeros, 0, l_tab_prefix, 0, zeros.length );
                    l_free_ent = TBL_FIRST - 1;

                    int n_bytes = l_n_bits << 3;
                    l_bit_pos = ( l_bit_pos - 1 ) + n_bytes - ( l_bit_pos - 1 + n_bytes ) % n_bytes;
                    l_n_bits = INIT_BITS;
                    l_maxcode = ( 1 << l_n_bits ) - 1;
                    l_bitmask = l_maxcode;

                    if ( debug )
                        System.err.println( "Code tables reset" );

                    l_bit_pos = resetbuf( l_bit_pos );
                    continue main_loop;
                }

                // setup

                int incode = code;
                l_stackp = l_stack.length;

                // Handle KwK case

                if ( code >= l_free_ent )
                {
                    if ( code > l_free_ent )
                        throw new IOException( "corrupt input: code=" + code + ", free_ent=" + l_free_ent );

                    l_stack[--l_stackp] = l_finchar;
                    code = l_oldcode;
                }

                // Generate output characters in reverse order

                while ( code >= 256 )
                {
                    l_stack[--l_stackp] = l_tab_suffix[code];
                    code = l_tab_prefix[code];
                }
                l_finchar = l_tab_suffix[code];
                buf[off++] = l_finchar;
                len--;

                // And put them out in forward order

                s_size = l_stack.length - l_stackp;
                int num = ( s_size >= len ) ? len : s_size;
                System.arraycopy( l_stack, l_stackp, buf, off, num );
                off += num;
                len -= num;
                l_stackp += num;

                // generate new entry in table

                if ( l_free_ent < l_maxmaxcode )
                {
                    l_tab_prefix[l_free_ent] = l_oldcode;
                    l_tab_suffix[l_free_ent] = l_finchar;
                    l_free_ent++;
                }

                // Remember previous code

                l_oldcode = incode;

                // if output buffer full, then return

                if ( len == 0 )
                {
                    n_bits = l_n_bits;
                    maxcode = l_maxcode;
                    bitmask = l_bitmask;
                    oldcode = l_oldcode;
                    finchar = l_finchar;
                    stackp = l_stackp;
                    free_ent = l_free_ent;
                    bit_pos = l_bit_pos;

                    return off - start;
                }
            }

            l_bit_pos = resetbuf( l_bit_pos );
        }
        while ( got > 0 );

        n_bits = l_n_bits;
        maxcode = l_maxcode;
        bitmask = l_bitmask;
        oldcode = l_oldcode;
        finchar = l_finchar;
        stackp = l_stackp;
        free_ent = l_free_ent;
        bit_pos = l_bit_pos;

        eof = true;
        return off - start;
    }

    /**
     * Moves the unread data in the buffer to the beginning and resets the pointers.
     */
    private final int resetbuf( int bit_pos )
    {
        int pos = bit_pos >> 3;
        System.arraycopy( data, pos, data, 0, end - pos );
        end -= pos;
        return 0;
    }

    private final void fill()
        throws IOException
    {
        got = in.read( data, end, data.length - 1 - end );
        if ( got > 0 )
            end += got;
    }

    public synchronized long skip( long num )
        throws IOException
    {
        byte[] tmp = new byte[(int) num];
        int got = read( tmp, 0, (int) num );

        if ( got > 0 )
            return (long) got;
        else
            return 0L;
    }

    public synchronized int available()
        throws IOException
    {
        if ( eof )
            return 0;

        return in.available();
    }

    private static final int LZW_MAGIC = 0x1f9d;

    private static final int MAX_BITS = 16;

    private static final int INIT_BITS = 9;

    private static final int HDR_MAXBITS = 0x1f;

    private static final int HDR_EXTENDED = 0x20;

    private static final int HDR_FREE = 0x40;

    private static final int HDR_BLOCK_MODE = 0x80;

    private void parse_header()
        throws IOException
    {
        // read in and check magic number

        int t = in.read();
        if ( t < 0 )
            throw new EOFException( "Failed to read magic number" );
        int magic = ( t & 0xff ) << 8;
        t = in.read();
        if ( t < 0 )
            throw new EOFException( "Failed to read magic number" );
        magic += t & 0xff;
        if ( magic != LZW_MAGIC )
            throw new IOException( "Input not in compress format (read " + "magic number 0x"
                + Integer.toHexString( magic ) + ")" );

        // read in header byte

        int header = in.read();
        if ( header < 0 )
            throw new EOFException( "Failed to read header" );

        block_mode = ( header & HDR_BLOCK_MODE ) > 0;
        maxbits = header & HDR_MAXBITS;

        if ( maxbits > MAX_BITS )
            throw new IOException( "Stream compressed with " + maxbits + " bits, but can only handle " + MAX_BITS
                + " bits" );

        if ( ( header & HDR_EXTENDED ) > 0 )
            throw new IOException( "Header extension bit set" );

        if ( ( header & HDR_FREE ) > 0 )
            throw new IOException( "Header bit 6 set" );

        if ( debug )
        {
            System.err.println( "block mode: " + block_mode );
            System.err.println( "max bits:   " + maxbits );
        }

        // initialize stuff

        maxmaxcode = 1 << maxbits;
        n_bits = INIT_BITS;
        maxcode = ( 1 << n_bits ) - 1;
        bitmask = maxcode;
        oldcode = -1;
        finchar = 0;
        free_ent = block_mode ? TBL_FIRST : 256;

        tab_prefix = new int[1 << maxbits];
        tab_suffix = new byte[1 << maxbits];
        stack = new byte[1 << maxbits];
        stackp = stack.length;

        for ( int idx = 255; idx >= 0; idx-- )
            tab_suffix[idx] = (byte) idx;
    }

    private static final boolean debug = false;

    public static void main( String args[] )
        throws Exception
    {
        if ( args.length != 1 )
        {
            System.err.println( "Usage: UncompressInputStream <file>" );
            System.exit( 1 );
        }

        InputStream in = new UncompressInputStream( new FileInputStream( args[0] ) );

        byte[] buf = new byte[100000];
        int tot = 0;
        long beg = System.currentTimeMillis();

        while ( true )
        {
            int got = in.read( buf );
            if ( got < 0 )
                break;
            System.out.write( buf, 0, got );
            tot += got;
        }

        long end = System.currentTimeMillis();
        System.err.println( "Decompressed " + tot + " bytes" );
        System.err.println( "Time: " + ( end - beg ) / 1000. + " seconds" );
    }
}