/*

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

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

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

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

package com.sun.java.util.jar.pack;

import java.io.*;

import java.util.*;

import java.util.jar.*;

import com.sun.java.util.jar.pack.Package.Class;

import com.sun.java.util.jar.pack.Package.InnerClass;

import com.sun.java.util.jar.pack.ConstantPool.*;

/**

 * Define the structure and ordering of "bands" in a packed file.

 * @author John Rose

 */

abstract

class BandStructure implements Constants {

    static final int MAX_EFFORT = 9;

    static final int MIN_EFFORT = 1;

    static final int DEFAULT_EFFORT = 5;

    // Inherit options from Pack200:

    PropMap p200 = Utils.currentPropMap();

    int verbose = p200.getInteger(Utils.DEBUG_VERBOSE);

    int effort = p200.getInteger(Pack200.Packer.EFFORT);

    { if (effort == 0)  effort = DEFAULT_EFFORT; }

    boolean optDumpBands = p200.getBoolean(Utils.COM_PREFIX+"dump.bands");

    boolean optDebugBands = p200.getBoolean(Utils.COM_PREFIX+"debug.bands");

    // Various heuristic options.

    boolean optVaryCodings = !p200.getBoolean(Utils.COM_PREFIX+"no.vary.codings");

    boolean optBigStrings = !p200.getBoolean(Utils.COM_PREFIX+"no.big.strings");

    abstract protected Index getCPIndex(byte tag);

    // Local copy of package version.

    private int packageMajver = -1;

    /** Call this exactly once, early, to specify the archive major version. */

    public void initPackageMajver(int packageMajver) throws IOException {

        assert(packageMajver > 0 && packageMajver < 0x10000);

        if (this.packageMajver > 0) {

            throw new IOException(

                "Package majver is already initialized to " + this.packageMajver+

                "; new setting is " + packageMajver);

        }

        this.packageMajver = packageMajver;

        adjustToMajver();

    }

    public int getPackageMajver() {

        if (packageMajver < 0) {

            throw new RuntimeException("Package majver not yet initialized");

        }

        return packageMajver;

    }

    private final boolean isReader = this instanceof PackageReader;

    protected BandStructure() {

    }

    final static Coding BYTE1 = Coding.of(1,256);

    final static Coding CHAR3 = Coding.of(3,128);

    // Note:  Tried sharper (3,16) with no post-zip benefit.

    // This is best used with BCI values:

    final static Coding BCI5 = Coding.of(5,4);  // mostly 1-byte offsets

    final static Coding BRANCH5 = Coding.of(5,4,2); // mostly forward branches

    final static Coding UNSIGNED5 = Coding.of(5,64);

    final static Coding UDELTA5 = UNSIGNED5.getDeltaCoding();

    // "sharp" (5,64) zips 0.4% better than "medium" (5,128)

    // It zips 1.1% better than "flat" (5,192)

    final static Coding SIGNED5 = Coding.of(5,64,1);  //sharp

    final static Coding DELTA5 = SIGNED5.getDeltaCoding();

    // Note:  Tried (5,128,2) and (5,192,2) with no benefit.

    final static Coding MDELTA5 = Coding.of(5,64,2).getDeltaCoding();

    final private static Coding[] basicCodings = {

        // Table of "Canonical BHSD Codings" from Pack200 spec.

        null,  // _meta_default

        // Fixed-length codings:

        Coding.of(1,256,0),

        Coding.of(1,256,1),

        Coding.of(1,256,0).getDeltaCoding(),

        Coding.of(1,256,1).getDeltaCoding(),

        Coding.of(2,256,0),

        Coding.of(2,256,1),

        Coding.of(2,256,0).getDeltaCoding(),

        Coding.of(2,256,1).getDeltaCoding(),

        Coding.of(3,256,0),

        Coding.of(3,256,1),

        Coding.of(3,256,0).getDeltaCoding(),

        Coding.of(3,256,1).getDeltaCoding(),

        Coding.of(4,256,0),

        Coding.of(4,256,1),

        Coding.of(4,256,0).getDeltaCoding(),

        Coding.of(4,256,1).getDeltaCoding(),

        // Full-range variable-length codings:

        Coding.of(5,  4,0),

        Coding.of(5,  4,1),

        Coding.of(5,  4,2),

        Coding.of(5, 16,0),

        Coding.of(5, 16,1),

        Coding.of(5, 16,2),

        Coding.of(5, 32,0),

        Coding.of(5, 32,1),

        Coding.of(5, 32,2),

        Coding.of(5, 64,0),

        Coding.of(5, 64,1),

        Coding.of(5, 64,2),

        Coding.of(5,128,0),

        Coding.of(5,128,1),

        Coding.of(5,128,2),

        Coding.of(5,  4,0).getDeltaCoding(),

        Coding.of(5,  4,1).getDeltaCoding(),

        Coding.of(5,  4,2).getDeltaCoding(),

        Coding.of(5, 16,0).getDeltaCoding(),

        Coding.of(5, 16,1).getDeltaCoding(),

        Coding.of(5, 16,2).getDeltaCoding(),

        Coding.of(5, 32,0).getDeltaCoding(),

        Coding.of(5, 32,1).getDeltaCoding(),

        Coding.of(5, 32,2).getDeltaCoding(),

        Coding.of(5, 64,0).getDeltaCoding(),

        Coding.of(5, 64,1).getDeltaCoding(),

        Coding.of(5, 64,2).getDeltaCoding(),

        Coding.of(5,128,0).getDeltaCoding(),

        Coding.of(5,128,1).getDeltaCoding(),

        Coding.of(5,128,2).getDeltaCoding(),

        // Variable length subrange codings:

        Coding.of(2,192,0),

        Coding.of(2,224,0),

        Coding.of(2,240,0),

        Coding.of(2,248,0),

        Coding.of(2,252,0),

        Coding.of(2,  8,0).getDeltaCoding(),

        Coding.of(2,  8,1).getDeltaCoding(),

        Coding.of(2, 16,0).getDeltaCoding(),

        Coding.of(2, 16,1).getDeltaCoding(),

        Coding.of(2, 32,0).getDeltaCoding(),

        Coding.of(2, 32,1).getDeltaCoding(),

        Coding.of(2, 64,0).getDeltaCoding(),

        Coding.of(2, 64,1).getDeltaCoding(),

        Coding.of(2,128,0).getDeltaCoding(),

        Coding.of(2,128,1).getDeltaCoding(),

        Coding.of(2,192,0).getDeltaCoding(),

        Coding.of(2,192,1).getDeltaCoding(),

        Coding.of(2,224,0).getDeltaCoding(),

        Coding.of(2,224,1).getDeltaCoding(),

        Coding.of(2,240,0).getDeltaCoding(),

        Coding.of(2,240,1).getDeltaCoding(),

        Coding.of(2,248,0).getDeltaCoding(),

        Coding.of(2,248,1).getDeltaCoding(),

        Coding.of(3,192,0),

        Coding.of(3,224,0),

        Coding.of(3,240,0),

        Coding.of(3,248,0),

        Coding.of(3,252,0),

        Coding.of(3,  8,0).getDeltaCoding(),

        Coding.of(3,  8,1).getDeltaCoding(),

        Coding.of(3, 16,0).getDeltaCoding(),

        Coding.of(3, 16,1).getDeltaCoding(),

        Coding.of(3, 32,0).getDeltaCoding(),

        Coding.of(3, 32,1).getDeltaCoding(),

        Coding.of(3, 64,0).getDeltaCoding(),

        Coding.of(3, 64,1).getDeltaCoding(),

        Coding.of(3,128,0).getDeltaCoding(),

        Coding.of(3,128,1).getDeltaCoding(),

        Coding.of(3,192,0).getDeltaCoding(),

        Coding.of(3,192,1).getDeltaCoding(),

        Coding.of(3,224,0).getDeltaCoding(),

        Coding.of(3,224,1).getDeltaCoding(),

        Coding.of(3,240,0).getDeltaCoding(),

        Coding.of(3,240,1).getDeltaCoding(),

        Coding.of(3,248,0).getDeltaCoding(),

        Coding.of(3,248,1).getDeltaCoding(),

        Coding.of(4,192,0),

        Coding.of(4,224,0),

        Coding.of(4,240,0),

        Coding.of(4,248,0),

        Coding.of(4,252,0),

        Coding.of(4,  8,0).getDeltaCoding(),

        Coding.of(4,  8,1).getDeltaCoding(),

        Coding.of(4, 16,0).getDeltaCoding(),

        Coding.of(4, 16,1).getDeltaCoding(),

        Coding.of(4, 32,0).getDeltaCoding(),

        Coding.of(4, 32,1).getDeltaCoding(),

        Coding.of(4, 64,0).getDeltaCoding(),

        Coding.of(4, 64,1).getDeltaCoding(),

        Coding.of(4,128,0).getDeltaCoding(),

        Coding.of(4,128,1).getDeltaCoding(),

        Coding.of(4,192,0).getDeltaCoding(),

        Coding.of(4,192,1).getDeltaCoding(),

        Coding.of(4,224,0).getDeltaCoding(),

        Coding.of(4,224,1).getDeltaCoding(),

        Coding.of(4,240,0).getDeltaCoding(),

        Coding.of(4,240,1).getDeltaCoding(),

        Coding.of(4,248,0).getDeltaCoding(),

        Coding.of(4,248,1).getDeltaCoding(),

        null

    };

    final private static HashMap basicCodingIndexes;

    static {

        assert(basicCodings[_meta_default] == null);

        assert(basicCodings[_meta_canon_min] != null);

        assert(basicCodings[_meta_canon_max] != null);

        HashMap map = new HashMap();

        for (int i = 0; i < basicCodings.length; i++) {

            Coding c = basicCodings[i];

            if (c == null)  continue;

            assert(i >= _meta_canon_min);

            assert(i <= _meta_canon_max);

            map.put(c, new Integer(i));

        }

        basicCodingIndexes = map;

    }

    public static Coding codingForIndex(int i) {

        return i < basicCodings.length ? basicCodings[i] : null;

    }

    public static int indexOf(Coding c) {

        Integer i = (Integer) basicCodingIndexes.get(c);

        if (i == null)  return 0;

        return i.intValue();

    }

    public static Coding[] getBasicCodings() {

        return (Coding[]) basicCodings.clone();

    }

    protected byte[] bandHeaderBytes;    // used for input only

    protected int    bandHeaderBytePos;  // BHB read pointer, for input only

    protected int    bandHeaderBytePos0; // for debug

    protected CodingMethod getBandHeader(int XB, Coding regularCoding) {

        CodingMethod[] res = {null};

        // push back XB onto the band header bytes

        bandHeaderBytes[--bandHeaderBytePos] = (byte) XB;

        bandHeaderBytePos0 = bandHeaderBytePos;

        // scan forward through XB and any additional band header bytes

        bandHeaderBytePos = parseMetaCoding(bandHeaderBytes,

                                            bandHeaderBytePos,

                                            regularCoding,

                                            res);

        return res[0];

    }

    public static int parseMetaCoding(byte[] bytes, int pos, Coding dflt, CodingMethod[] res) {

        if ((bytes[pos] & 0xFF) == _meta_default) {

            res[0] = dflt;

            return pos+1;

        }

        int pos2;

        pos2 = Coding.parseMetaCoding(bytes, pos, dflt, res);

        if (pos2 > pos)  return pos2;

        pos2 = PopulationCoding.parseMetaCoding(bytes, pos, dflt, res);

        if (pos2 > pos)  return pos2;

        pos2 = AdaptiveCoding.parseMetaCoding(bytes, pos, dflt, res);

        if (pos2 > pos)  return pos2;

        throw new RuntimeException("Bad meta-coding op "+(bytes[pos]&0xFF));

    }

    static final int SHORT_BAND_HEURISTIC = 100;

    public static final int NO_PHASE        = 0;

    // package writing phases:

    public static final int COLLECT_PHASE   = 1; // collect data before write

    public static final int FROZEN_PHASE    = 3; // no longer collecting

    public static final int WRITE_PHASE     = 5; // ready to write bytes

    // package reading phases:

    public static final int EXPECT_PHASE    = 2; // gather expected counts

    public static final int READ_PHASE      = 4; // ready to read bytes

    public static final int DISBURSE_PHASE  = 6; // pass out data after read

    public static final int DONE_PHASE      = 8; // done writing or reading

    static boolean phaseIsRead(int p) {

        return (p % 2) == 0;

    }

    static int phaseCmp(int p0, int p1) {

        assert((p0 % 2) == (p1 % 2) || (p0 % 8) == 0 || (p1 % 8) == 0);

        return p0 - p1;

    }

    /** The packed file is divided up into a number of segments.

     *  Most segments are typed as ValueBand, strongly-typed sequences

     *  of integer values, all interpreted in a single way.

     *  A few segments are ByteBands, which hetergeneous sequences

     *  of bytes.

     *

     *  The two phases for writing a packed file are COLLECT and WRITE.

     *  1. When writing a packed file, each band collects

     *  data in an ad-hoc order.

     *  2. At the end, each band is assigned a coding scheme,

     *  and then all the bands are written in their global order.

     *

     *  The three phases for reading a packed file are EXPECT, READ,

     *  and DISBURSE.

     *  1. For each band, the expected number of integers  is determined.

     *  2. The data is actually read from the file into the band.

     *  3. The band pays out its values as requested, in an ad hoc order.

     *

     *  When the last phase of a band is done, it is marked so (DONE).

     *  Clearly, these phases must be properly ordered WRT each other.

     */

    abstract class Band {

        private int    phase = NO_PHASE;

        private final  String name;

        private int    valuesExpected;

        protected long outputSize = -1;  // cache

        final public Coding regularCoding;

        final public int seqForDebug;

        public int       elementCountForDebug;

        protected Band(String name, Coding regularCoding) {

            this.name = name;

            this.regularCoding = regularCoding;

            this.seqForDebug = ++nextSeqForDebug;

            if (verbose > 2)

                Utils.log.fine("Band "+seqForDebug+" is "+name);

            // caller must call init

        }

        public Band init() {

            // Cannot due this from the constructor, because constructor

            // may wish to initialize some subclass variables.

            // Set initial phase for reading or writing:

            if (isReader)

                readyToExpect();

            else

                readyToCollect();

            return this;

        }

        // common operations

        boolean isReader() { return isReader; }

        int phase() { return phase; }

        String name() { return name; }

        /** Return -1 if data buffer not allocated, else max length. */

        public abstract int capacity();

        /** Allocate data buffer to specified length. */

        protected abstract void setCapacity(int cap);

        /** Return current number of values in buffer, which must exist. */

        public abstract int length();

        protected abstract int valuesRemainingForDebug();

        public final int valuesExpected() {

            return valuesExpected;

        }

        /** Write out bytes, encoding the values. */

        public final void writeTo(OutputStream out) throws IOException {

            assert(assertReadyToWriteTo(this, out));

            setPhase(WRITE_PHASE);

            // subclasses continue by writing their contents to output

            writeDataTo(out);

            doneWriting();

        }

        abstract void chooseBandCodings() throws IOException;

        public final long outputSize() {

            if (outputSize >= 0) {

                long size = outputSize;

                assert(size == computeOutputSize());

                return size;

            }

            return computeOutputSize();

        }

        protected abstract long computeOutputSize();

        abstract protected void writeDataTo(OutputStream out) throws IOException;

        /** Expect a certain number of values. */

        void expectLength(int l) {

            assert(assertPhase(this, EXPECT_PHASE));

            assert(valuesExpected == 0);  // all at once

            assert(l >= 0);

            valuesExpected = l;

        }

        /** Expect more values.  (Multiple calls accumulate.) */

        void expectMoreLength(int l) {

            assert(assertPhase(this, EXPECT_PHASE));

            valuesExpected += l;

        }

        /// Phase change markers.

        private void readyToCollect() { // called implicitly by constructor

            setCapacity(1);

            setPhase(COLLECT_PHASE);

        }

        protected void doneWriting() {

            assert(assertPhase(this, WRITE_PHASE));

            setPhase(DONE_PHASE);

        }

        private void readyToExpect() { // called implicitly by constructor

            setPhase(EXPECT_PHASE);

        }

        /** Read in bytes, decoding the values. */

        public final void readFrom(InputStream in) throws IOException {

            assert(assertReadyToReadFrom(this, in));

            setCapacity(valuesExpected());

            setPhase(READ_PHASE);

            // subclasses continue by reading their contents from input:

            readDataFrom(in);

            readyToDisburse();

        }

        abstract protected void readDataFrom(InputStream in) throws IOException;

        protected void readyToDisburse() {

            if (verbose > 1)  Utils.log.fine("readyToDisburse "+this);

            setPhase(DISBURSE_PHASE);

        }

        public void doneDisbursing() {

            assert(assertPhase(this, DISBURSE_PHASE));

            setPhase(DONE_PHASE);

        }

        public final void doneWithUnusedBand() {

            if (isReader) {

                assert(assertPhase(this, EXPECT_PHASE));

                assert(valuesExpected() == 0);

                // Fast forward:

                setPhase(READ_PHASE);

                setPhase(DISBURSE_PHASE);

                setPhase(DONE_PHASE);

            } else {

                setPhase(FROZEN_PHASE);

            }

        }

        protected void setPhase(int newPhase) {

            assert(assertPhaseChangeOK(this, phase, newPhase));

            this.phase = newPhase;

        }

        protected int lengthForDebug = -1;  // DEBUG ONLY

        public String toString() {  // DEBUG ONLY

            int length = (lengthForDebug != -1 ? lengthForDebug : length());

            String str = name;

            if (length != 0)

                str += "[" + length + "]";

            if (elementCountForDebug != 0)

                str += "(" + elementCountForDebug + ")";

            return str;

        }

    }

    class ValueBand extends Band {

        private int[]  values;   // must be null in EXPECT phase

        private int    length;

        private int    valuesDisbursed;

        private CodingMethod bandCoding;

        private byte[] metaCoding;

        protected ValueBand(String name, Coding regularCoding) {

            super(name, regularCoding);

        }

        public int capacity() {

            return values == null ? -1 : values.length;

        }

        /** Declare predicted or needed capacity. */

        protected void setCapacity(int cap) {

            assert(length <= cap);

            if (cap == -1) { values = null; return; }

            values = realloc(values, cap);

        }

        public int length() {

            return length;

        }

        protected int valuesRemainingForDebug() {

            return length - valuesDisbursed;

        }

        protected int valueAtForDebug(int i) {

            return values[i];

        }

        void patchValue(int i, int value) {