/*

 * 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

 * published by the Free Software Foundation.  Oracle designates this

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

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

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

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

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

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

import java.io.IOException;

import java.io.OutputStream;

import java.io.PrintStream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import static com.sun.java.util.jar.pack.Constants.*;

/**

 * Writer for a package file.

 * @author John Rose

 */

class PackageWriter extends BandStructure {

    Package pkg;

    OutputStream finalOut;

    PackageWriter(Package pkg, OutputStream out) throws IOException {

        this.pkg = pkg;

        this.finalOut = out;

        // Caller has specified archive version in the package:

        initPackageMajver(pkg.package_majver);

    }

    void write() throws IOException {

        boolean ok = false;

        try {

            if (verbose > 0) {

                Utils.log.info("Setting up constant pool...");

            }

            setup();

            if (verbose > 0) {

                Utils.log.info("Packing...");

            }

            // writeFileHeader() is done last, since it has ultimate counts

            // writeBandHeaders() is called after all other bands are done

            writeConstantPool();

            writeFiles();

            writeAttrDefs();

            writeInnerClasses();

            writeClassesAndByteCodes();

            writeAttrCounts();

            if (verbose > 1)  printCodeHist();

            // choose codings (fill band_headers if needed)

            if (verbose > 0) {

                Utils.log.info("Coding...");

            }

            all_bands.chooseBandCodings();

            // now we can write the headers:

            writeFileHeader();

            writeAllBandsTo(finalOut);

            ok = true;

        } catch (Exception ee) {

            Utils.log.warning("Error on output: "+ee, ee);

            //if (verbose > 0)  ee.printStackTrace();

            // Write partial output only if we are verbose.

            if (verbose > 0)  finalOut.close();

            if (ee instanceof IOException)  throw (IOException)ee;

            if (ee instanceof RuntimeException)  throw (RuntimeException)ee;

            throw new Error("error packing", ee);

        }

    }

    Set<Entry>                       requiredEntries;  // for the CP

    Map<Attribute.Layout, int[]>     backCountTable;   // for layout callables

    int[][]     attrCounts;       // count attr. occurences

    void setup() {

        requiredEntries = new HashSet<>();

        setArchiveOptions();

        trimClassAttributes();

        collectAttributeLayouts();

        pkg.buildGlobalConstantPool(requiredEntries);

        setBandIndexes();

        makeNewAttributeBands();

        collectInnerClasses();

    }

    void setArchiveOptions() {

        // Decide on some archive options early.

        // Does not decide on: AO_HAVE_SPECIAL_FORMATS,

        // AO_HAVE_CP_NUMBERS, AO_HAVE_FILE_HEADERS.

        // Also, AO_HAVE_FILE_OPTIONS may be forced on later.

        int minModtime = pkg.default_modtime;

        int maxModtime = pkg.default_modtime;

        int minOptions = -1;

        int maxOptions = 0;

        // Import defaults from package (deflate hint, etc.).

        archiveOptions |= pkg.default_options;

        for (File file : pkg.files) {

            int modtime = file.modtime;

            int options = file.options;

            if (minModtime == NO_MODTIME) {

                minModtime = maxModtime = modtime;

            } else {

                if (minModtime > modtime)  minModtime = modtime;

                if (maxModtime < modtime)  maxModtime = modtime;

            }

            minOptions &= options;

            maxOptions |= options;

        }

        if (pkg.default_modtime == NO_MODTIME) {

            // Make everything else be a positive offset from here.

            pkg.default_modtime = minModtime;

        }

        if (minModtime != NO_MODTIME && minModtime != maxModtime) {

            // Put them into a band.

            archiveOptions |= AO_HAVE_FILE_MODTIME;

        }

        // If the archive deflation is set do not bother with each file.

        if (!testBit(archiveOptions,AO_DEFLATE_HINT) && minOptions != -1) {

            if (testBit(minOptions, FO_DEFLATE_HINT)) {

                // Every file has the deflate_hint set.

                // Set it for the whole archive, and omit options.

                archiveOptions |= AO_DEFLATE_HINT;

                minOptions -= FO_DEFLATE_HINT;

                maxOptions -= FO_DEFLATE_HINT;

            }

            pkg.default_options |= minOptions;

            if (minOptions != maxOptions

                || minOptions != pkg.default_options) {

                archiveOptions |= AO_HAVE_FILE_OPTIONS;

            }

        }

        // Decide on default version number (majority rule).

        Map<Integer, int[]> verCounts = new HashMap<>();

        int bestCount = 0;

        int bestVersion = -1;

        for (Class cls : pkg.classes) {

            int version = cls.getVersion();

            int[] var = verCounts.get(version);

            if (var == null) {

                var = new int[1];

                verCounts.put(version, var);

            }

            int count = (var[0] += 1);

            //System.out.println("version="+version+" count="+count);

            if (bestCount < count) {

                bestCount = count;

                bestVersion = version;

            }

        }

        verCounts.clear();

        if (bestVersion == -1)  bestVersion = 0;  // degenerate case

        int bestMajver = (char)(bestVersion >>> 16);

        int bestMinver = (char)(bestVersion);

        pkg.default_class_majver = (short) bestMajver;

        pkg.default_class_minver = (short) bestMinver;

        String bestVerStr = Package.versionStringOf(bestMajver, bestMinver);

        if (verbose > 0)

           Utils.log.info("Consensus version number in segment is "+bestVerStr);

        if (verbose > 0)

            Utils.log.info("Highest version number in segment is "+

                           Package.versionStringOf(pkg.getHighestClassVersion()));

        // Now add explicit pseudo-attrs. to classes with odd versions.

        for (Class cls : pkg.classes) {

            if (cls.getVersion() != bestVersion) {

                Attribute a = makeClassFileVersionAttr(cls.minver, cls.majver);

                if (verbose > 1) {

                    String clsVer = cls.getVersionString();

                    String pkgVer = bestVerStr;

                    Utils.log.fine("Version "+clsVer+" of "+cls

                                     +" doesn't match package version "

                                     +pkgVer);

                }

                // Note:  Does not add in "natural" order.  (Who cares?)

                cls.addAttribute(a);

            }

        }

        // Decide if we are transmitting a huge resource file:

        for (File file : pkg.files) {

            long len = file.getFileLength();

            if (len != (int)len) {

                archiveOptions |= AO_HAVE_FILE_SIZE_HI;

                if (verbose > 0)

                   Utils.log.info("Note: Huge resource file "+file.getFileName()+" forces 64-bit sizing");

                break;

            }

        }

        // Decide if code attributes typically have sub-attributes.

        // In that case, to preserve compact 1-byte code headers,

        // we must declare unconditional presence of code flags.

        int cost0 = 0;

        int cost1 = 0;

        for (Class cls : pkg.classes) {

            for (Class.Method m : cls.getMethods()) {

                if (m.code != null) {

                    if (m.code.attributeSize() == 0) {

                        // cost of a useless unconditional flags byte

                        cost1 += 1;

                    } else if (shortCodeHeader(m.code) != LONG_CODE_HEADER) {

                        // cost of inflating a short header

                        cost0 += 3;

                    }

                }

            }

        }

        if (cost0 > cost1) {

            archiveOptions |= AO_HAVE_ALL_CODE_FLAGS;

        }

        if (verbose > 0)

            Utils.log.info("archiveOptions = "

                             +"0b"+Integer.toBinaryString(archiveOptions));

    }

    void writeFileHeader() throws IOException {

        pkg.checkVersion();

        writeArchiveMagic();

        writeArchiveHeader();

    }

    // Local routine used to format fixed-format scalars

    // in the file_header:

    private void putMagicInt32(int val) throws IOException {

        int res = val;

        for (int i = 0; i < 4; i++) {

            archive_magic.putByte(0xFF & (res >>> 24));

            res <<= 8;

        }

    }

    void writeArchiveMagic() throws IOException {

        putMagicInt32(pkg.magic);

    }

    void writeArchiveHeader() throws IOException {

        // for debug only:  number of words optimized away

        // AO_HAVE_SPECIAL_FORMATS is set if non-default

        // coding techniques are used, or if there are

        // compressor-defined attributes transmitted.

        boolean haveSpecial = testBit(archiveOptions, AO_HAVE_SPECIAL_FORMATS);

        if (!haveSpecial) {

            haveSpecial |= (band_headers.length() != 0);

            haveSpecial |= (attrDefsWritten.length != 0);

            if (haveSpecial)

                archiveOptions |= AO_HAVE_SPECIAL_FORMATS;

        }

        // AO_HAVE_FILE_HEADERS is set if there is any

        // file or segment envelope information present.

        boolean haveFiles = testBit(archiveOptions, AO_HAVE_FILE_HEADERS);

        if (!haveFiles) {

            haveFiles |= (archiveNextCount > 0);

            haveFiles |= (pkg.default_modtime != NO_MODTIME);

            if (haveFiles)

                archiveOptions |= AO_HAVE_FILE_HEADERS;

        }

        // AO_HAVE_CP_NUMBERS is set if there are any numbers

        // in the global constant pool.  (Numbers are in 15% of classes.)

        boolean haveNumbers = testBit(archiveOptions, AO_HAVE_CP_NUMBERS);

        if (!haveNumbers) {

            haveNumbers |= pkg.cp.haveNumbers();

            if (haveNumbers)

                archiveOptions |= AO_HAVE_CP_NUMBERS;

        }

        assert(pkg.package_majver > 0);  // caller must specify!

        archive_header_0.putInt(pkg.package_minver);

        archive_header_0.putInt(pkg.package_majver);

        if (verbose > 0)

            Utils.log.info("Package Version for this segment:"+

                           Package.versionStringOf(pkg.getPackageVersion()));

        archive_header_0.putInt(archiveOptions); // controls header format

        assert(archive_header_0.length() == AH_LENGTH_0);

        final int DUMMY = 0;

        if (haveFiles) {

            assert(archive_header_S.length() == AH_ARCHIVE_SIZE_HI);

            archive_header_S.putInt(DUMMY); // (archiveSize1 >>> 32)

            assert(archive_header_S.length() == AH_ARCHIVE_SIZE_LO);

            archive_header_S.putInt(DUMMY); // (archiveSize1 >>> 0)

            assert(archive_header_S.length() == AH_LENGTH_S);

        }

        // Done with unsized part of header....

        if (haveFiles) {

            archive_header_1.putInt(archiveNextCount);  // usually zero

            archive_header_1.putInt(pkg.default_modtime);

            archive_header_1.putInt(pkg.files.size());

        } else {

            assert(pkg.files.isEmpty());

        }

        if (haveSpecial) {

            archive_header_1.putInt(band_headers.length());

            archive_header_1.putInt(attrDefsWritten.length);

        } else {

            assert(band_headers.length() == 0);

            assert(attrDefsWritten.length == 0);

        }

        archive_header_1.putInt(pkg.getAllInnerClasses().size());

        archive_header_1.putInt(pkg.default_class_minver);

        archive_header_1.putInt(pkg.default_class_majver);

        archive_header_1.putInt(pkg.classes.size());

        assert(archive_header_0.length() +

               archive_header_S.length() +

               archive_header_1.length()

        // Figure out all the sizes now, first cut:

        archiveSize0 = 0;

        archiveSize1 = all_bands.outputSize();

        // Second cut:

        archiveSize0 += archive_magic.outputSize();

        archiveSize0 += archive_header_0.outputSize();

        archiveSize0 += archive_header_S.outputSize();

        // Make the adjustments:

        archiveSize1 -= archiveSize0;

        // Patch the header:

        if (haveFiles) {

            int archiveSizeHi = (int)(archiveSize1 >>> 32);

            int archiveSizeLo = (int)(archiveSize1 >>> 0);

            archive_header_S.patchValue(AH_ARCHIVE_SIZE_HI, archiveSizeHi);

            archive_header_S.patchValue(AH_ARCHIVE_SIZE_LO, archiveSizeLo);

            int zeroLen = UNSIGNED5.getLength(DUMMY);

            archiveSize0 += UNSIGNED5.getLength(archiveSizeHi) - zeroLen;

            archiveSize0 += UNSIGNED5.getLength(archiveSizeLo) - zeroLen;

        }

        if (verbose > 1)

            Utils.log.fine("archive sizes: "+

                             archiveSize0+"+"+archiveSize1);

        assert(all_bands.outputSize() == archiveSize0+archiveSize1);

    }

            int count = pkg.cp.getIndexByTag(tag).size();

            switch (tag) {

            case CONSTANT_Utf8:

                // The null string is always first.

                if (count > 0)

                    assert(pkg.cp.getIndexByTag(tag).get(0)

                           == ConstantPool.getUtf8Entry(""));

                break;

            case CONSTANT_Integer:

            case CONSTANT_Float:

            case CONSTANT_Long:

            case CONSTANT_Double:

                // Omit counts for numbers if possible.

                if (!haveNumbers) {

                    assert(count == 0);

                    continue;

                }

                break;

            }

            archive_header_1.putInt(count);

        }

    }

    protected Index getCPIndex(byte tag) {

        return pkg.cp.getIndexByTag(tag);

    }

// (The following observations are out of date; they apply only to

// "banding" the constant pool itself.  Later revisions of this algorithm

// applied the banding technique to every part of the package file,

// applying the benefits more broadly.)

// Note:  Keeping the data separate in passes (or "bands") allows the

// compressor to issue significantly shorter indexes for repeated data.

// The difference in zipped size is 4%, which is remarkable since the

// unzipped sizes are the same (only the byte order differs).

// After moving similar data into bands, it becomes natural to delta-encode

// each band.  (This is especially useful if we sort the constant pool first.)

// Delta encoding saves an extra 5% in the output size (13% of the CP itself).

// Because a typical delta usees much less data than a byte, the savings after

// zipping is even better:  A zipped delta-encoded package is 8% smaller than

// a zipped non-delta-encoded package.  Thus, in the zipped file, a banded,

// delta-encoded constant pool saves over 11% (of the total file size) compared

// with a zipped unbanded file.

    void writeConstantPool() throws IOException {

        IndexGroup cp = pkg.cp;

        if (verbose > 0)  Utils.log.info("Writing CP");

            Index index = cp.getIndexByTag(tag);

            Entry[] cpMap = index.cpMap;

            if (verbose > 0)

                Utils.log.info("Writing "+cpMap.length+" "+ConstantPool.tagName(tag)+" entries...");

            if (optDumpBands) {

                try (PrintStream ps = new PrintStream(getDumpStream(index, ".idx"))) {

                    printArrayTo(ps, cpMap, 0, cpMap.length);

                }

            }

            switch (tag) {

            case CONSTANT_Utf8:

                writeUtf8Bands(cpMap);

                break;

            case CONSTANT_Integer:

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

                    NumberEntry e = (NumberEntry) cpMap[i];

                    int x = ((Integer)e.numberValue()).intValue();

                    cp_Int.putInt(x);

                }

                break;

            case CONSTANT_Float:

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

                    NumberEntry e = (NumberEntry) cpMap[i];

                    float fx = ((Float)e.numberValue()).floatValue();

                    int x = Float.floatToIntBits(fx);

                    cp_Float.putInt(x);

                }

                break;

            case CONSTANT_Long:

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

                    NumberEntry e = (NumberEntry) cpMap[i];

                    long x = ((Long)e.numberValue()).longValue();

                    cp_Long_hi.putInt((int)(x >>> 32));

                    cp_Long_lo.putInt((int)(x >>> 0));

                }

                break;

            case CONSTANT_Double:

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

                    NumberEntry e = (NumberEntry) cpMap[i];

                    double dx = ((Double)e.numberValue()).doubleValue();

                    long x = Double.doubleToLongBits(dx);

                    cp_Double_hi.putInt((int)(x >>> 32));

                    cp_Double_lo.putInt((int)(x >>> 0));

                }

                break;

            case CONSTANT_String:

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

                    StringEntry e = (StringEntry) cpMap[i];

                    cp_String.putRef(e.ref);

                }

                break;

            case CONSTANT_Class: