/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2007 Sun Microsystems, Inc.

 */

package org.apidesign.bck2brwsr.emul.zip;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.Method;

import java.util.zip.ZipEntry;

import java.util.zip.ZipInputStream;

import org.apidesign.bck2brwsr.core.Exported;

import org.apidesign.bck2brwsr.core.JavaScriptBody;

/**

 *

 * @author Tomas Zezula

 */

public final class FastJar {

    private final byte[] arr;

    public FastJar(byte[] arr) {

        this.arr = arr;

    }

    private static final int GIVE_UP = 1<<16;

    public static final  class Entry {

        public final String name;

        final long offset;

        private final long dosTime;

        Entry (String name, long offset, long time) {

            assert name != null;

            this.name = name;

            this.offset = offset;

            this.dosTime = time;

        }        

/*        

        public long getTime () {

            Date d = new Date((int)(((dosTime >> 25) & 0x7f) + 80),

                    (int)(((dosTime >> 21) & 0x0f) - 1),

                    (int)((dosTime >> 16) & 0x1f),

                    (int)((dosTime >> 11) & 0x1f),

                    (int)((dosTime >> 5) & 0x3f),

                    (int)((dosTime << 1) & 0x3e));

            return d.getTime();

        }

        */

    }

    public InputStream getInputStream (final Entry e) throws IOException {

        return getInputStream(arr, e.offset);

    }

    private static InputStream getInputStream (byte[] arr, final long offset) throws IOException {

        ByteArrayInputStream is = new ByteArrayInputStream(arr);

        is.skip(offset);

        ZipInputStream in = new ZipInputStream (is);

        ZipEntry e = in.getNextEntry();

        if (e != null && e.getCrc() == 0L && e.getMethod() == ZipEntry.STORED) {

            int cp = arr.length - is.available();

            return new ByteArrayInputStream(arr, cp, (int)e.getSize());

        }

        return in;

    }

    public Entry[] list() throws IOException {

        final int size = arr.length;

        int at = size - ZipInputStream.ENDHDR;

        byte[] data = new byte[ZipInputStream.ENDHDR];        

        int giveup = 0;

        do {

            FastJar.arraycopy(arr, at, data, 0, data.length);

            at--;

            giveup++;

            if (giveup > GIVE_UP) {

                throw new IOException ();

            }

        } while (getsig(data) != ZipInputStream.ENDSIG);

        final long censize = endsiz(data);

        final long cenoff  = endoff(data);

        at = (int) cenoff;                                                     

        Entry[] result = new Entry[0];

        int cenread = 0;

        data = new byte[ZipInputStream.CENHDR];

        while (cenread < censize) {

            FastJar.arraycopy(arr, at, data, 0, data.length);

            at += data.length;

            if (getsig(data) != ZipInputStream.CENSIG) {

                throw new IOException("No central table");          //NOI18N

            }

            int cennam = cennam(data);

            int cenext = cenext(data);

            int cencom = cencom(data);

            long lhoff = cenoff(data);

            long centim = centim(data);

            String name = new String(arr, at, cennam, "UTF-8");

            at += cennam;

            int seekby = cenext+cencom;

            int cendatalen = ZipInputStream.CENHDR + cennam + seekby;

            cenread+=cendatalen;

            result = addEntry(result, new Entry(name,lhoff, centim));

            at += seekby;

        }

        return result;

    }

    private Entry[] addEntry(Entry[] result, Entry entry) {

        Entry[] e = new Entry[result.length + 1];

        e[result.length] = entry;

        FastJar.arraycopy(result, 0, e, 0, result.length);

        return e;

    }

    private static final long getsig(final byte[] b) throws IOException {return get32(b,0);}

    private static final long endsiz(final byte[] b) throws IOException {return get32(b,ZipInputStream.ENDSIZ);}

    private static final long endoff(final byte[] b) throws IOException {return get32(b,ZipInputStream.ENDOFF);}

    private static final long  cenlen(final byte[] b) throws IOException {return get32(b,ZipInputStream.CENLEN);}

    private static final long  censiz(final byte[] b) throws IOException {return get32(b,ZipInputStream.CENSIZ);}

    private static final long centim(final byte[] b) throws IOException {return get32(b,ZipInputStream.CENTIM);}

    private static final int  cennam(final byte[] b) throws IOException {return get16(b,ZipInputStream.CENNAM);}

    private static final int  cenext(final byte[] b) throws IOException {return get16(b,ZipInputStream.CENEXT);}

    private static final int  cencom(final byte[] b) throws IOException {return get16(b,ZipInputStream.CENCOM);}

    private static final long cenoff (final byte[] b) throws IOException {return get32(b,ZipInputStream.CENOFF);}

    private static final int lochow(final byte[] b) throws IOException {return get16(b,ZipInputStream.LOCHOW);}

    private static final int locname(final byte[] b) throws IOException {return get16(b,ZipInputStream.LOCNAM);}

    private static final int locext(final byte[] b) throws IOException {return get16(b,ZipInputStream.LOCEXT);}

    private static final long locsiz(final byte[] b) throws IOException {return get32(b,ZipInputStream.LOCSIZ);}

    private static final int get16(final byte[] b, int off) throws IOException {        

        final int b1 = b[off];

	final int b2 = b[off+1];

        return (b1 & 0xff) | ((b2 & 0xff) << 8);

    }

    private static final long get32(final byte[] b, int off) throws IOException {

	final int s1 = get16(b, off);

	final int s2 = get16(b, off+2);

        return s1 | ((long)s2 << 16);

    }

    @JavaScriptBody(args = {"value", "srcBegin", "dst", "dstBegin", "count"}, body

            = "if (srcBegin < dstBegin) {\n"

            + "    while (count-- > 0) {\n"

            + "        dst[dstBegin + count] = value[srcBegin + count];\n"

            + "    }\n"

            + "} else {\n"

            + "    while (count-- > 0) {\n"

            + "        dst[dstBegin++] = value[srcBegin++];\n"

            + "    }\n"

            + "}"

    )

    @Exported

    static void arraycopy(Object src, int srcBegin, Object dst, int dstBegin, int count) {

        try {

            Class<?> system = Class.forName("java.lang.System");

            Method m = system.getMethod("arraycopy", Object.class, int.class, Object.class, int.class, int.class);

            m.invoke(null, src, srcBegin, dst, dstBegin, count);

        } catch (Exception ex) {

            throw new IllegalStateException(ex);

        }

    }

}