/*

 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.

 * 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 java.util.jar.Pack200;

import com.sun.java.util.jar.pack.Attribute.Layout;

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

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

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

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

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

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

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

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.SequenceInputStream;

import java.lang.reflect.Modifier;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import java.util.Map;

import java.util.Set;

import java.util.jar.JarFile;

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

/**

 * Define the main data structure transmitted by pack/unpack.

 * @author John Rose

 */

class Package {

    int verbose;

    {

        PropMap pmap = Utils.currentPropMap();

        if (pmap != null)

            verbose = pmap.getInteger(Utils.DEBUG_VERBOSE);

    }

    final int magic = JAVA_PACKAGE_MAGIC;

    int default_modtime = NO_MODTIME;

    int default_options = 0;  // FO_DEFLATE_HINT

    Version defaultClassVersion = null;

    // These fields can be adjusted by driver properties.

    final Version minClassVersion;

    final Version maxClassVersion;

    // null, indicates that consensus rules during package write

    final Version packageVersion;

    Version observedHighestClassVersion = null;

    // What constants are used in this unit?

    ConstantPool.IndexGroup cp = new ConstantPool.IndexGroup();

    /*

     * typically used by the PackageReader to set the defaults, in which

     * case we take the defaults.

     */

    public Package() {

        minClassVersion = JAVA_MIN_CLASS_VERSION;

        maxClassVersion = JAVA_MAX_CLASS_VERSION;

        packageVersion = null;

    }

    /*

     * Typically used by the PackerImpl during before packing, the defaults are

     * overridden by the users preferences.

     */

    public Package(Version minClassVersion, Version maxClassVersion, Version packageVersion) {

        // Fill in permitted range of major/minor version numbers.

        this.minClassVersion = minClassVersion == null

                ? JAVA_MIN_CLASS_VERSION

                : minClassVersion;

        this.maxClassVersion = maxClassVersion == null

                ? JAVA_MAX_CLASS_VERSION

                : maxClassVersion;

        this.packageVersion  = packageVersion;

    }

    public void reset() {

        cp = new ConstantPool.IndexGroup();

        classes.clear();

        files.clear();

        BandStructure.nextSeqForDebug = 0;

        observedHighestClassVersion = null;

    }

    // Special empty versions of Code and InnerClasses, used for markers.

    public static final Attribute.Layout attrCodeEmpty;

    public static final Attribute.Layout attrBootstrapMethodsEmpty;

    public static final Attribute.Layout attrInnerClassesEmpty;

    public static final Attribute.Layout attrSourceFileSpecial;

    public static final Map<Attribute.Layout, Attribute> attrDefs;

    static {

        Map<Layout, Attribute> ad = new HashMap<>(3);

        attrCodeEmpty = Attribute.define(ad, ATTR_CONTEXT_METHOD,

                                         "Code", "").layout();

        attrBootstrapMethodsEmpty = Attribute.define(ad, ATTR_CONTEXT_CLASS,

                                                     "BootstrapMethods", "").layout();

        attrInnerClassesEmpty = Attribute.define(ad, ATTR_CONTEXT_CLASS,

                                                 "InnerClasses", "").layout();

        attrSourceFileSpecial = Attribute.define(ad, ATTR_CONTEXT_CLASS,

                                                 "SourceFile", "RUNH").layout();

        attrDefs = Collections.unmodifiableMap(ad);

    }

    Version getDefaultClassVersion() {

        return defaultClassVersion;

    }

    /** Return the highest version number of all classes,

     *  or 0 if there are no classes.

     */

    private void setHighestClassVersion() {

        if (observedHighestClassVersion != null)

            return;

        Version res = JAVA_MIN_CLASS_VERSION;  // initial low value

        for (Class cls : classes) {

            Version ver = cls.getVersion();

            if (res.lessThan(ver))  res = ver;

        }

        observedHighestClassVersion = res;

    }

    Version getHighestClassVersion() {

        setHighestClassVersion();

        return observedHighestClassVersion;

    }

    // What Java classes are in this unit?

    ArrayList<Package.Class> classes = new ArrayList<>();

    public List<Package.Class> getClasses() {

        return classes;

    }

    public final

    class Class extends Attribute.Holder implements Comparable<Class> {

        public Package getPackage() { return Package.this; }

        // Optional file characteristics and data source (a "class stub")

        File file;

        // File header

        int magic;

        Version version;

        // Local constant pool (one-way mapping of index => package cp).

        Entry[] cpMap;

        // Class header

        //int flags;  // in Attribute.Holder.this.flags

        ClassEntry thisClass;

        ClassEntry superClass;

        ClassEntry[] interfaces;

        // Class parts

        ArrayList<Field> fields;

        ArrayList<Method> methods;

        //ArrayList attributes;  // in Attribute.Holder.this.attributes

        // Note that InnerClasses may be collected at the package level.

        ArrayList<InnerClass> innerClasses;

        ArrayList<BootstrapMethodEntry> bootstrapMethods;

        Class(int flags, ClassEntry thisClass, ClassEntry superClass, ClassEntry[] interfaces) {

            this.magic      = JAVA_MAGIC;

            this.version    = defaultClassVersion;

            this.flags      = flags;

            this.thisClass  = thisClass;

            this.superClass = superClass;

            this.interfaces = interfaces;

            boolean added = classes.add(this);

            assert(added);

        }

        Class(String classFile) {

            // A blank class; must be read with a ClassReader, etc.

            initFile(newStub(classFile));

        }

        List<Field> getFields() { return fields == null ? noFields : fields; }

        List<Method> getMethods() { return methods == null ? noMethods : methods; }

        public String getName() {

            return thisClass.stringValue();

        }

        Version getVersion() {

            return this.version;

        }

        // Note:  equals and hashCode are identity-based.

        public int compareTo(Class that) {

            String n0 = this.getName();

            String n1 = that.getName();

            return n0.compareTo(n1);

        }

        String getObviousSourceFile() {

            return Package.getObviousSourceFile(getName());

        }

        private void transformSourceFile(boolean minimize) {

            // Replace "obvious" SourceFile by null.

            Attribute olda = getAttribute(attrSourceFileSpecial);

            if (olda == null)

                return;  // no SourceFile attr.

            String obvious = getObviousSourceFile();

            List<Entry> ref = new ArrayList<>(1);

            olda.visitRefs(this, VRM_PACKAGE, ref);

            Utf8Entry sfName = (Utf8Entry) ref.get(0);

            Attribute a = olda;

            if (sfName == null) {

                if (minimize) {

                    // A pair of zero bytes.  Cannot use predef. layout.

                    a = Attribute.find(ATTR_CONTEXT_CLASS, "SourceFile", "H");

                    a = a.addContent(new byte[2]);

                } else {

                    // Expand null attribute to the obvious string.

                    byte[] bytes = new byte[2];

                    sfName = getRefString(obvious);

                    Object f = null;

                    f = Fixups.addRefWithBytes(f, bytes, sfName);

                    a = attrSourceFileSpecial.addContent(bytes, f);

                }

            } else if (obvious.equals(sfName.stringValue())) {

                if (minimize) {

                    // Replace by an all-zero attribute.

                    a = attrSourceFileSpecial.addContent(new byte[2]);

                } else {

                    assert(false);

                }

            }

            if (a != olda) {

                if (verbose > 2)

                    Utils.log.fine("recoding obvious SourceFile="+obvious);

                List<Attribute> newAttrs = new ArrayList<>(getAttributes());

                int where = newAttrs.indexOf(olda);

                newAttrs.set(where, a);

                setAttributes(newAttrs);

            }

        }

        void minimizeSourceFile() {

            transformSourceFile(true);

        }

        void expandSourceFile() {

            transformSourceFile(false);

        }

        protected Entry[] getCPMap() {

            return cpMap;

        }

        protected void setCPMap(Entry[] cpMap) {

            this.cpMap = cpMap;

        }

        boolean hasBootstrapMethods() {

            return bootstrapMethods != null && !bootstrapMethods.isEmpty();

        }

        List<BootstrapMethodEntry> getBootstrapMethods() {

            return bootstrapMethods;

        }

        BootstrapMethodEntry[] getBootstrapMethodMap() {

            return (hasBootstrapMethods())

                    ? bootstrapMethods.toArray(new BootstrapMethodEntry[bootstrapMethods.size()])

                    : null;

        }

        void setBootstrapMethods(Collection<BootstrapMethodEntry> bsms) {

            assert(bootstrapMethods == null);  // do not do this twice

            bootstrapMethods = new ArrayList<>(bsms);

        }

        boolean hasInnerClasses() {

            return innerClasses != null;

        }

        List<InnerClass> getInnerClasses() {

            return innerClasses;

        }

        public void setInnerClasses(Collection<InnerClass> ics) {

            innerClasses = (ics == null) ? null : new ArrayList<>(ics);

            // Edit the attribute list, if necessary.

            Attribute a = getAttribute(attrInnerClassesEmpty);

            if (innerClasses != null && a == null)

                addAttribute(attrInnerClassesEmpty.canonicalInstance());

            else if (innerClasses == null && a != null)

                removeAttribute(a);

        }

        /** Given a global map of ICs (keyed by thisClass),

         *  compute the subset of its Map.values which are

         *  required to be present in the local InnerClasses

         *  attribute.  Perform this calculation without

         *  reference to any actual InnerClasses attribute.

         *  <p>

         *  The order of the resulting list is consistent

         *  with that of Package.this.allInnerClasses.

         */

        public List<InnerClass> computeGloballyImpliedICs() {

            Set<Entry> cpRefs = new HashSet<>();

            {   // This block temporarily displaces this.innerClasses.

                ArrayList<InnerClass> innerClassesSaved = innerClasses;

                innerClasses = null;  // ignore for the moment

                visitRefs(VRM_CLASSIC, cpRefs);

                innerClasses = innerClassesSaved;

            }

            ConstantPool.completeReferencesIn(cpRefs, true);

            Set<Entry> icRefs = new HashSet<>();

            for (Entry e : cpRefs) {

                // Restrict cpRefs to InnerClasses entries only.

                if (!(e instanceof ClassEntry))  continue;

                // For every IC reference, add its outers also.

                while (e != null) {

                    InnerClass ic = getGlobalInnerClass(e);

                    if (ic == null)  break;

                    if (!icRefs.add(e))  break;

                    e = ic.outerClass;

                    // If we add A$B$C to the mix, we must also add A$B.

                }

            }

            // This loop is structured this way so as to accumulate

            // entries into impliedICs in an order which reflects

            // the order of allInnerClasses.

            ArrayList<InnerClass> impliedICs = new ArrayList<>();

            for (InnerClass ic : allInnerClasses) {

                // This one is locally relevant if it describes

                // a member of the current class, or if the current

                // class uses it somehow.  In the particular case

                // where thisClass is an inner class, it will already

                // be a member of icRefs.

                if (icRefs.contains(ic.thisClass)

                    || ic.outerClass == this.thisClass) {

                    // Add every relevant class to the IC attribute:

                    if (verbose > 1)

                        Utils.log.fine("Relevant IC: "+ic);

                    impliedICs.add(ic);

                }

            }

            return impliedICs;

        }

        // Helper for both minimizing and expanding.

        // Computes a symmetric difference.

        private List<InnerClass> computeICdiff() {

            List<InnerClass> impliedICs = computeGloballyImpliedICs();

            List<InnerClass> actualICs  = getInnerClasses();

            if (actualICs == null)

                actualICs = Collections.emptyList();

            // Symmetric difference is calculated from I, A like this:

            //  diff = (I+A) - (I*A)

            // Note that the center C is unordered, but the result

            // preserves the original ordering of I and A.

            //

            // Class file rules require that outers precede inners.

            // So, add I before A, in case A$B$Z is local, but A$B

            // is implicit.  The reverse is never the case.

            if (actualICs.isEmpty()) {

                return impliedICs;

                // Diff is I since A is empty.

            }

            if (impliedICs.isEmpty()) {

                return actualICs;

                // Diff is A since I is empty.

            }

            // (I*A) is non-trivial

            Set<InnerClass> center = new HashSet<>(actualICs);

            center.retainAll(new HashSet<>(impliedICs));

            impliedICs.addAll(actualICs);

            impliedICs.removeAll(center);

            // Diff is now I^A = (I+A)-(I*A).

            return impliedICs;

        }

        /** When packing, anticipate the effect of expandLocalICs.

         *  Replace the local ICs by their symmetric difference

         *  with the globally implied ICs for this class; if this

         *  difference is empty, remove the local ICs altogether.

         *  <p>

         *  An empty local IC attribute is reserved to signal

         *  the unpacker to delete the attribute altogether,

         *  so a missing local IC attribute signals the unpacker

         *  to use the globally implied ICs changed.

         */

        void minimizeLocalICs() {

            List<InnerClass> diff = computeICdiff();

            List<InnerClass> actualICs = innerClasses;

            List<InnerClass> localICs;  // will be the diff, modulo edge cases

            if (diff.isEmpty()) {

                // No diff, so transmit no attribute.

                localICs = null;

                if (actualICs != null && actualICs.isEmpty()) {

                    // Odd case:  No implied ICs, and a zero length attr.

                    // Do not support it directly.

                    if (verbose > 0)

                        Utils.log.info("Warning: Dropping empty InnerClasses attribute from "+this);

                }

            } else if (actualICs == null) {

                // No local IC attribute, even though some are implied.

                // Signal with trivial attribute.

                localICs = Collections.emptyList();

            } else {

                // Transmit a non-empty diff, which will create

                // a local ICs attribute.

                localICs = diff;

            }

            // Reduce the set to the symmetric difference.

            setInnerClasses(localICs);

            if (verbose > 1 && localICs != null)

                Utils.log.fine("keeping local ICs in "+this+": "+localICs);

        }

        /** When unpacking, undo the effect of minimizeLocalICs.

         *  Must return negative if any IC tuples may have been deleted.

         *  Otherwise, return positive if any IC tuples were added.

         */

        int expandLocalICs() {

            List<InnerClass> localICs = innerClasses;

            List<InnerClass> actualICs;

            int changed;

            if (localICs == null) {

                // Diff was empty.  (Common case.)

                List<InnerClass> impliedICs = computeGloballyImpliedICs();

                if (impliedICs.isEmpty()) {

                    actualICs = null;

                    changed = 0;

                } else {

                    actualICs = impliedICs;

                    changed = 1;  // added more tuples

                }

            } else if (localICs.isEmpty()) {

                // It was a non-empty diff, but the local ICs were absent.

                actualICs = null;

                changed = 0;  // [] => null, no tuple change

            } else {

                // Non-trivial diff was transmitted.

                actualICs = computeICdiff();

                // If we only added more ICs, return +1.

                changed = actualICs.containsAll(localICs)? +1: -1;

            }

            setInnerClasses(actualICs);

            return changed;

        }

        public abstract

        class Member extends Attribute.Holder implements Comparable<Member> {

            DescriptorEntry descriptor;

            protected Member(int flags, DescriptorEntry descriptor) {

                this.flags = flags;

                this.descriptor = descriptor;

            }

            public Class thisClass() { return Class.this; }

            public DescriptorEntry getDescriptor() {

                return descriptor;

            }

            public String getName() {

                return descriptor.nameRef.stringValue();

            }

            public String getType() {

                return descriptor.typeRef.stringValue();

            }

            protected Entry[] getCPMap() {