import java.io.Closeable;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.zip.DataFormatException;
import java.util.zip.Inflater;

public class CabTestCase {

    public static void main(String[] arguments) throws IOException {
        File inputFile= new File(arguments[0]);
        File outputFile= new File(arguments[1]);
        if (outputFile.exists()) {
            outputFile.delete();
        }
        CABFile input = new CABFile(new FileInputStream(inputFile));
        OutputStream output = new FileOutputStream(outputFile);
        byte[] buffer = new byte[8192];
        int length;
        CABFile.PayloadEntry entry;
        while ((entry = input.getNextEntry()) != null) {
            InputStream entryStream = entry.getEntryStream();
            while ((length = entryStream.read(buffer)) != -1) {
                output.write(buffer, 0, length);
            }
        }
        input.close();
        output.close();
    }

    public static class MSZipInputStream extends InputStream {

        private static byte MSZIP1 = 0x43;
        private static byte MSZIP2 = 0x4B;

        private InputStream input;
        private int lastRead;
        private byte[] buffer = new byte[32*1024];
        private Inflater inflater = new Inflater(true);

        public MSZipInputStream(InputStream input) throws IOException {
            this.input = input;
            fill(true);
        }

        // returns true if more bytes were read into the buffer
        private boolean fill(boolean newBlock) throws IOException {
            int length;
            if (newBlock) {
                length = input.read(buffer, 0, 2);
                if (length == -1) {
                    return false;
                }
                if (buffer[0] != MSZIP1 || buffer[1] != MSZIP2) {
                    throw new IOException("Unexpected data in MSZIP compressed file");
                }
            }
            length = input.read(buffer, 0, buffer.length);
            if (length != -1) {
                inflater.setInput(buffer, 0, length);
                lastRead = length;
            }
            return length != -1;
        }

        public int read(byte[] outBuffer, int offset, int length) throws IOException {
            if (length == 0) {
                return 0;
            }
            try {
                while (true) {
                    int inflated =  inflater.inflate(outBuffer, offset, length);
                    if (inflated > 0) {
                        return inflated;
                    }
                    if (inflater.needsInput()) {
                        if (!fill(false)) {
                            throw new IOException("Unexpected EOF while decompressing data");
                        }
                    } else if (inflater.needsDictionary()) {
                        throw new IOException("Unable to decompress input stream; dictionary required");
                    } else if (inflater.finished()) {
                        if (finishOrReset()) {
                            return -1;
                        }
                    }
                }
            } catch (DataFormatException e) {
                throw new IOException(e);
            }
        }

        // returns true if we are completely finished
        private boolean finishOrReset() throws IOException {
            int remaining = inflater.getRemaining();
            inflater.reset();
            // Creating a new instance instead of resetting did not fix the bug
//            inflater = new Inflater(true);
            if (remaining == 0) {
                return !fill(true);
            } else if (remaining > 2) {
                if (buffer[lastRead-remaining] != MSZIP1
                        || buffer[lastRead-remaining+1] != MSZIP2) {
                    throw new IOException("Unexpected data in MSZIP compressed file");
                }
                inflater.setInput(buffer, lastRead-remaining+2, remaining-2);
                return false;
            } else {
                // corner cases, 1 or 2 bytes remaining
                byte byte2;
                if (remaining == 1) {
                    byte2 = (byte) input.read();
                } else {
                    byte2 = buffer[lastRead-remaining+1];
                }
                if (buffer[lastRead-remaining] != MSZIP1 || byte2 != MSZIP2) {
                    throw new IOException("Unexpected data in MSZIP compressed file");
                }
                return !fill(false);
            }
        }

        public int read() throws IOException {
            byte[] single = new byte[1];
            if (read(single, 0, 1) == -1) {
                return -1;
            } else {
                return single[0];
            }
        }
    }

     public static class CABFile {
        private CFHeader m_header;
        private Map<Integer, CFFolder> m_folders;
        // folders in order of appearance in the stream
        private Set<CFFolder> m_streamOrderFolders;
        private Map<Integer,CFFile>   m_files;

        private CountingInputStream m_cis;
        private CABDataInputStream m_dis;

        private Iterator<CFFolder> m_folderIterator;
        private CFFolder m_currentFolder;
        private Iterator<CFFile> m_fileIterator;

        public CABFile(InputStream is) throws IOException  {
            super();
            m_cis=new CountingInputStream(is);
            m_dis = new CABDataInputStream(m_cis);
            m_header=new CFHeader(m_dis);

            m_folders = new HashMap<Integer, CFFolder>((m_header.getCFolders()<<1)+1);
            m_streamOrderFolders=new TreeSet<CFFolder>(new Comparator<CFFolder>(){

                public int compare(CFFolder o1, CFFolder o2) {
                    long l_off1=o1.getCoffCabStart();
                    long l_off2=o2.getCoffCabStart();
                    if( l_off1<l_off2) return -1;
                    else if ( l_off1>l_off2) return 1;
                    else return 0;
                }
            });
            m_files = new HashMap<Integer, CFFile>((m_header.getCFiles()<<1)+1);
            for ( int i = 0; i < m_header.getCFolders(); i++ ) {
                CFFolder l_folder = new CFFolder(m_dis,m_header);
                m_folders.put(i,l_folder);
                m_streamOrderFolders.add(l_folder);
            }
            for ( int i =0; i < m_header.getCFiles(); i++) {
                CFFile l_file;
                m_files.put(i, l_file=new CFFile(m_dis,m_header));
                CFFolder l_owner = m_folders.get(l_file.getIFolder());
                CFHeader._assert(l_owner!=null, "No folder for cab file %d(%s)", i,l_file.getSzName());
                l_owner.addFile(l_file);
                l_file.setOwner(l_owner);

            }
            m_folderIterator=m_streamOrderFolders.iterator();
            m_fileIterator=null;

        }

        public PayloadEntry getNextEntry() throws IOException {

            while ( m_fileIterator==null || ! m_fileIterator.hasNext()) {

                if ( m_folderIterator == null ||
                        ! m_folderIterator.hasNext() ) {
                    if ( m_currentFolder != null ) {
                        m_currentFolder.close();
                        m_currentFolder=null;
                    }
                    return null;
                }


                if ( m_currentFolder != null ) m_currentFolder.close();
                m_currentFolder=m_folderIterator.next();
                m_fileIterator=m_currentFolder.iterator();
            }

            CFFile l_file=m_fileIterator.next();
            return new PayloadEntry(l_file,l_file.getFileStream(m_cis));

        }

        public void close() throws IOException {

            m_dis.close();
        }

        class PayloadEntry {

            private CFFile m_cfFile;
            private InputStream m_entryStream;

            PayloadEntry(CFFile file, InputStream entryStream ) {
                m_cfFile = file;
                m_entryStream = entryStream;
            }

            public InputStream getEntryStream() throws IOException {
                return m_entryStream;
            }

        }

    }

     public static class CFFile {

        private long cbFile;/* uncompressed size of this file in bytes */
        private long uoffFolderStart;/* uncompressed offset of this file in the folder */
        private int iFolder;/* index into the CFFOLDER area */
        private int date;/* date stamp for this file */
        private int time;/* time stamp for this file */
        private int attribs;/* attribute flags for this file */
        private String szName;/* name of this file */

        private CFFolder m_owner;
        private InputStream m_fileStream;

        public CFFile(CABDataInputStream dis, CFHeader header ) throws IOException {
            super();
            _readFromStream(dis,header);
        }

        void setOwner ( CFFolder owner )  {
            m_owner = owner;
        }

        private void _readFromStream ( CABDataInputStream dis, CFHeader header ) throws IOException {
            cbFile=dis.readIntLE()&0xffffffffl;
            uoffFolderStart=dis.readIntLE()&0xffffffffl;
            iFolder=dis.readShortLE()&0xffff;
            date = dis.readShortLE()&0xffff;
            time = dis.readShortLE()&0xffff;
            attribs=dis.readShortLE()&0xffff;
            szName=CFHeader._readASCIIString(dis, CFHeader.MAX_STR_LEN);
        }

        public long getCbFile() {
            return cbFile;
        }

        public long getUoffFolderStart() {
            return uoffFolderStart;
        }

        public int getIFolder() {
            return iFolder;
        }

        public int getDate() {
            return date;
        }

        public int getTime() {
            return time;
        }

        public int getAttribs() {
            return attribs;
        }

        public String getSzName() {
            return szName;
        }

        InputStream getFileStream (CountingInputStream cis) throws IOException {
            if ( m_fileStream!=null ) return m_fileStream;
            CountingInputStream l_ownerIs = m_owner.getFolderUncompressedStream(cis);
            return m_fileStream=new EntryStreamWrapper(l_ownerIs,getUoffFolderStart(),getCbFile());
        }


    }

     public static class CFFolder  implements Iterable<CFFile>, Closeable {

        public static final int tcompMASK_TYPE = 0x000F;  // Mask for compression type

        public static final int tcompTYPE_NONE = 0x0000;  // No compression
        public static final int tcompTYPE_MSZIP = 0x0001;  // MSZIP

        private long coffCabStart;/* offset of the first CFDATA block in this folder */
        private int   cCFData;/* number of CFDATA blocks in this folder */
        private int typeCompress;/* compression type indicator */
        private byte  abReserve[];/* (optional) per-folder reserved area */

        private Set<CFFile> m_files;
        private CFHeader m_header;

        private CountingInputStream m_folderUncompStream;



        public Iterator<CFFile> iterator() {
            return m_files.iterator();
        }

        public CFFolder(CABDataInputStream is, CFHeader header) throws IOException {
            super();
            m_header=header;
            m_files = new TreeSet<CFFile>(new Comparator<CFFile>()
            {
                // compare in order of appearance in the
                // folder stream
                public int compare(CFFile o1, CFFile o2) {
                    long l_off1=o1.getUoffFolderStart();
                    long l_off2=o2.getUoffFolderStart();
                    if ( l_off1 < l_off2 ) return -1;
                    else if ( l_off1> l_off2) return 1;
                    else return 0;
                }
            });
            _readFromStream(is, header);
        }

        private void _readFromStream ( CABDataInputStream is, CFHeader header ) throws IOException {
            coffCabStart=is.readIntLE()&0xffffffffl;
            cCFData=is.readShortLE()&0xffff;
            typeCompress=is.readShortLE()&0xffff;
            if ( ( header.getFlags()&CFHeader.cfhdrRESERVE_PRESENT) != 0 ) {
                abReserve=new byte[header.getCbCFFolder()];
                is.readFully(abReserve);
            }
        }

        void addFile ( CFFile file ) {
            m_files.add(file);
        }

        public long getCoffCabStart() {
            return coffCabStart;
        }

        public int getCCFData() {
            return cCFData;
        }

        public int getTypeCompress() {
            return typeCompress&tcompMASK_TYPE;
        }

        public byte[] getAbReserve() {
            return abReserve;
        }

        InputStream createFolderRawStream ( final CountingInputStream cis ) throws IOException {
            long l_offset=cis.getByteCount();
            CFHeader._assert( coffCabStart>=l_offset,
                    "CAB folder offset is unreachable in the stream:needed offset:%d, but current offset is already %d.",
                    coffCabStart,
                    l_offset);

            cis.skip(coffCabStart-l_offset);

            assert cis.getByteCount()== coffCabStart;

            final CABDataInputStream l_dis = new CABDataInputStream( cis);
            return new InputStream () {

                int m_cfDataCnt=0;
                CFData m_currentCFData;
                int    m_left=0;

                private boolean moreCharacters() throws IOException {
                    while ( m_left==0 ) {
                        if ( m_cfDataCnt>=getCCFData() ) return false; // at end

                        m_currentCFData=new CFData(l_dis, m_header);
                        m_cfDataCnt++;
                        m_left=m_currentCFData.getCbData();

                    }
                    return true;
                }

                @Override
                public int read() throws IOException {
                    if ( ! moreCharacters() ) return -1;
                    int l_ch=cis.read();
                    m_left--;
                    CFHeader._assert(l_ch>=0, "Unexpected EOF during parsing CFDATA entry");
                    return l_ch;
                }


                @Override
                public int read(byte[] b, int off, int len) throws IOException {
                    int l_bytesRead=0;
                    while ( len >0 ) {
                        if ( ! moreCharacters() )
                            return l_bytesRead==0?-1:l_bytesRead;
                        int l_copyBytes=Math.min(len, m_left);
                        int l_read=cis.read(b,off,l_copyBytes);

                        // DEBUG
//if ( l_read<0 )
//System.out.printf("here");

                        CFHeader._assert(l_read>=0, "Unexpected EOF during parsing CFDATA entry");
                        l_bytesRead+=l_read;
                        off+=l_read;
                        len-=l_read;
                        m_left-=l_read;
                    }
                    return l_bytesRead;
                }

                @Override
                public void close() throws IOException {
                    // skip till the end of the entry?? next entry will skip anyway
                }
            };
        }

        /**
         * returns entry uncompressed stream
         */

        CountingInputStream getFolderUncompressedStream (CountingInputStream cis) throws IOException {

            if ( m_folderUncompStream!= null ) return m_folderUncompStream;

            InputStream l_rawIs=createFolderRawStream(cis);
            switch ( typeCompress & tcompMASK_TYPE ) {
                case tcompTYPE_MSZIP:
                    return m_folderUncompStream=new CountingInputStream(new MSZipInputStream(l_rawIs));
                default:
                    CFHeader._assert(false, "unsupported compression type: %d",typeCompress&tcompMASK_TYPE);
                    return null; // not reached
            }
        }

        public void close() throws IOException {
            // release decomp resourses
            m_folderUncompStream=null;

        }

    }

     public static class CFHeader {

        public final byte[] CAB_SIG = new byte[] { 'M','S','C','F' };

        public static final int cfhdrPREV_CABINET = 0x0001;
        public static final int cfhdrNEXT_CABINET = 0x0002;
        public static final int cfhdrRESERVE_PRESENT = 0x0004;

        public static final int MAX_STR_LEN = 255;


        private byte[] signature=new byte[4];/* cabinet file signature */
        private int  reserved1;/* reserved */
        private long cbCabinet;/* size of this cabinet file in bytes */
        private int  reserved2;/* reserved */
        private long  coffFiles;/* offset of the first CFFILE entry */
        private int  reserved3;/* reserved */
        private short versionMinor;/* cabinet file format version, minor */
        private short versionMajor;/* cabinet file format version, major */
        private int  cFolders;/* number of CFFOLDER entries in this cabinet */
        private int  cFiles;/* number of CFFILE entries in this cabinet */
        private short  flags;/* cabinet file option indicators */
        private int  setID;/* must be the same for all cabinets in a set */
        private int  iCabinet;/* number of this cabinet file in a set */
        private int  cbCFHeader; /* (optional) size of per-cabinet reserved area */
        private short cbCFFolder; /* (optional) size of per-folder reserved area */
        private short cbCFData; /* (optional) size of per-datablock reserved area */
        private byte abReserve[];/* (optional) per-cabinet reserved area */
        private String szCabinetPrev;/* (optional) name of previous cabinet file */
        private String szDiskPrev;/* (optional) name of previous disk */
        private String szCabinetNext;/* (optional) name of next cabinet file */
        private String szDiskNext;/* (optional) name of next disk */

        public CFHeader(CABDataInputStream is) throws IOException {
            super();
            _readFromStream(is);
        }


        private void _readFromStream ( CABDataInputStream dis ) throws IOException {
            dis.readFully(signature);
            _assert(Arrays.equals(CAB_SIG, signature), "Cab magic not recognized");
            reserved1=dis.readInt();
            cbCabinet=dis.readIntLE()&0xffffffffL; // unsigned 32bit per spec
            reserved2=dis.readInt();
            coffFiles=dis.readIntLE()&0xffffffffL; // unsigned 32bit per spec
            reserved3=dis.readInt();
            versionMinor=(short) (dis.readByte()&0xff);
            versionMajor=(short) (dis.readByte()&0xff);
            cFolders=dis.readShortLE()&0xffff;
            cFiles=dis.readShortLE()&0xffff;
            flags=dis.readShortLE();
            setID=dis.readShortLE()&0xffff;
            iCabinet=dis.readShortLE()&0xffff;
            if ( (flags&cfhdrRESERVE_PRESENT) != 0 ) {
                cbCFHeader=dis.readShortLE()&0xffff;
                cbCFFolder=(short)(dis.readByte()&0xff);
                cbCFData=(short)(dis.readByte()&0xff);

                abReserve=new byte[cbCFHeader];
                dis.readFully(abReserve);
            }
            if ((flags&cfhdrPREV_CABINET) != 0 ) {
                szCabinetPrev=_readASCIIString(dis, MAX_STR_LEN);
                szDiskPrev=_readASCIIString(dis, MAX_STR_LEN);
            }
            if ((flags&cfhdrNEXT_CABINET)!= 0 ) {
                szCabinetNext=_readASCIIString(dis, MAX_STR_LEN);
                szDiskNext=_readASCIIString(dis, MAX_STR_LEN);
            }
        }


        public byte[] getSignature() {
            return signature;
        }

        public int getReserved1() {
            return reserved1;
        }


        public long getCbCabinet() {
            return cbCabinet;
        }


        public int getReserved2() {
            return reserved2;
        }


        public long getCoffFiles() {
            return coffFiles;
        }


        public int getReserved3() {
            return reserved3;
        }


        public short getVersionMinor() {
            return versionMinor;
        }


        public short getVersionMajor() {
            return versionMajor;
        }


        public int getCFolders() {
            return cFolders;
        }


        public int getCFiles() {
            return cFiles;
        }


        public short getFlags() {
            return flags;
        }


        public int getSetID() {
            return setID;
        }


        public int getICabinet() {
            return iCabinet;
        }


        public int getCbCFHeader() {
            return cbCFHeader;
        }


        public short getCbCFFolder() {
            return cbCFFolder;
        }


        public short getCbCFData() {
            return cbCFData;
        }


        public byte[] getAbReserve() {
            return abReserve;
        }


        public String getSzCabinetPrev() {
            return szCabinetPrev;
        }


        public String getSzDiskPrev() {
            return szDiskPrev;
        }


        public String getSzCabinetNext() {
            return szCabinetNext;
        }


        public String getSzDiskNext() {
            return szDiskNext;
        }


        static String _readASCIIString ( DataInputStream dis, int maxLen ) throws IOException {
            byte [] l_strBytes=new byte[maxLen];
            int l_strLen;
            for ( l_strLen=0; l_strLen<maxLen; l_strLen++ ) {
                if ( 0==(l_strBytes[l_strLen]=dis.readByte()))
                    break;
            }
            if ( l_strLen==maxLen && l_strBytes[maxLen-1]!=0 )
                _assert ( 0==dis.readByte(),
                        "ASCII string length exceeded maxumum length of %d.", maxLen);
            return new String ( l_strBytes, 0, l_strLen, "US-ASCII");
        }

        static void _assert(boolean cond, String msgFormat, Object... args ) throws IOException {
            if (!cond ) throw new IOException ( String.format ( msgFormat, args));
        }


     }

     public static class CABDataInputStream extends DataInputStream {

        public CABDataInputStream(InputStream in) {
            super(in);
        }

        public long readLongLE() throws IOException {
            long l_be=readLong();

            long l_acc=0;
            for ( int i = 0; i < 8;i++) {
                l_acc<<=8;
                l_acc|=l_be&0xff;
                l_be>>>=8;
            }
            return l_acc;

        }

        public int readIntLE() throws IOException {
            int l_be=readInt();

            int l_acc=0;
            for ( int i = 0; i < 4;i++) {
                l_acc<<=8;
                l_acc|=l_be&0xff;
                l_be>>>=8;
            }
            return l_acc;
        }

        public short readShortLE() throws IOException {
            int l_be=readShort()&0xffff;
            return (short)((l_be <<8)|(l_be>>>8));
        }

    }

    public static class EntryStreamWrapper extends InputStream {

        private long m_offset, m_len;
        private CountingInputStream m_cis;
        private boolean m_closed;

        public EntryStreamWrapper(CountingInputStream cis, long entryOffset, long entryLen ) throws IOException {
            super();
            m_cis=cis;
            m_offset=entryOffset;
            m_len = entryLen;
            m_closed=false;

            assert entryLen>=0;

            long l_skip = entryOffset - m_cis.getByteCount();
            if ( l_skip < 0 ) throw new IOException ( String.format(
                    "Unable to skip to position %d since we are already at postion %d which is past the position requested.",
                    entryOffset, m_cis.getByteCount()
            ));
            m_cis.skip(l_skip);
        }

        public int available() throws IOException {
            if ( m_closed ) throw new IOException ( "closed stream");
            return m_cis.available();
        }

        public void close() throws IOException {
            if ( m_closed ) throw new IOException ( "closed stream");
            m_closed=true;
        }

        public void mark(int idx) {
            m_cis.mark(idx);
        }

        public boolean markSupported() {
            return m_cis.markSupported();
        }

        public int read() throws IOException {
            if ( m_closed ) throw new IOException ( "closed stream");
            if ( m_cis.getByteCount()>= m_offset+m_len ) return -1;
            return m_cis.read();
        }

        public int read(byte[] b, int off, int len) throws IOException {
            if ( m_closed ) throw new IOException ( "closed stream");
            long l_cbLeft = m_len +m_offset-m_cis.getByteCount();
            if ( l_cbLeft <=0 ) return -1;
            if ( l_cbLeft < len ) len = l_cbLeft>Integer.MAX_VALUE?Integer.MAX_VALUE:(int)l_cbLeft;
            return m_cis.read(b, off, len);
        }

        public int read(byte[] b) throws IOException {
            return read ( b, 0, b.length);
        }

        public void reset() throws IOException {
            if ( m_closed ) throw new IOException ( "closed stream");
            m_cis.reset();
        }

        public long skip(long length) throws IOException {
            if ( m_closed ) throw new IOException ( "closed stream");
            long l_cbLeft = m_len +m_offset-m_cis.getByteCount();
            if ( length > l_cbLeft ) length=l_cbLeft;
            return m_cis.skip(length);
        }

    }

    public static class CFData {

        private long  csum;/* checksum of this CFDATA entry */
        private int  cbData;/* number of compressed bytes in this block */
        private int cbUncomp;/* number of uncompressed bytes in this block */
        private byte  abReserve[];/* (optional) per-datablock reserved area */

        public CFData(CABDataInputStream dis, CFHeader header) throws IOException {
            super();
            _readFromStream(dis, header);
        }

        private void _readFromStream ( CABDataInputStream dis, CFHeader header ) throws IOException {
            csum=dis.readIntLE()&0xffffffffl;
            cbData=dis.readShortLE()&0xffff;
            cbUncomp=dis.readShortLE()&0xffff;
            if ( ( header.getFlags()&CFHeader.cfhdrRESERVE_PRESENT) != 0 ) {
                abReserve= new byte[header.getCbCFData()];
                dis.readFully(abReserve);
            }
        }

        public long getCsum() {
            return csum;
        }

        public int getCbData() {
            return cbData;
        }

        public int getCbUncomp() {
            return cbUncomp;
        }

        public byte[] getAbReserve() {
            return abReserve;
        }
    }

    public static class CountingInputStream extends FilterInputStream {
        private long byteCount = 0;

        public CountingInputStream(InputStream in) {
            super(in);
        }

        public long getByteCount() {
            return byteCount;
        }

        public int read() throws IOException {
            int count = super.read();
            byteCount += count >= 0 ? 1 : 0;
            return count;
        }

        public int read(byte[] b, int off, int len) throws IOException {
            int count = super.read(b, off, len);
            byteCount += count >= 0 ? count : 0;
            return count;
        }
    }
}