/*

 * Copyright (c) 2009, 2017, 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 java.lang.module;

import java.io.InputStream;

import java.io.IOException;

import java.io.PrintStream;

import java.io.UncheckedIOException;

import java.nio.ByteBuffer;

import java.nio.file.Path;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Objects;

import java.util.Optional;

import java.util.Set;

import java.util.function.Supplier;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import static jdk.internal.module.Checks.*;

import static java.util.Objects.*;

import jdk.internal.module.Checks;

import jdk.internal.module.ModuleInfo;

/**

 * A module descriptor.

 *

 * <p> A module descriptor describes a named module and defines methods to

 * obtain each of its components. The module descriptor for a named module

 * in the Java virtual machine is obtained by invoking the {@link

 * java.lang.Module Module}'s {@link java.lang.Module#getDescriptor

 * getDescriptor} method. Module descriptors can also be created using the

 * {@link ModuleDescriptor.Builder} class or by reading the binary form of a

 * module declaration ({@code module-info.class}) using the {@link

 * #read(InputStream,Supplier) read} methods defined here. </p>

 *

 * <p> A module descriptor describes a <em>normal</em>, open, or automatic

 * module. <em>Normal</em> modules and open modules describe their {@link

 * #requires() dependences}, {@link #exports() exported-packages}, the services

 * that they {@link #uses() use} or {@link #provides() provide}, and other

 * components. <em>Normal</em> modules may {@link #opens() open} specific

 * packages. The module descriptor for an open modules does not declare any

 * open packages (its {@code opens} method returns an empty set) but when

 * instantiated in the Java virtual machine then it is treated as if all

 * packages are open. The module descriptor for an automatic module does not

 * declare any dependences (except for the mandatory dependency on {@code

 * java.base}), and does not declare any exported or open packages. Automatic

 * module receive special treatment during resolution so that they read all

 * other modules in the configuration. When an automatic module is instantiated

 * in the Java virtual machine then it reads every unnamed module and is

 * treated as if all packages are exported and open. </p>

 *

 * <p> {@code ModuleDescriptor} objects are immutable and safe for use by

 * multiple concurrent threads.</p>

 *

 * @see java.lang.Module

 * @since 9

 * @spec JPMS

 */

public class ModuleDescriptor

    implements Comparable<ModuleDescriptor>

{

    /**

     * A modifier on a module.

     *

     * @see ModuleDescriptor#modifiers()

     * @since 9

     * @spec JPMS

     */

    public static enum Modifier {

        /**

         * An open module. An open module does not declare any open packages

         * but the resulting module is treated as if all packages are open.

         */

        OPEN,

        /**

         * An automatic module. An automatic module is treated as if it exports

         * and opens all packages.

         *

         * @apiNote This modifier does not correspond to a module flag in the

         * binary form of a module declaration ({@code module-info.class}).

         */

        AUTOMATIC,

        /**

         * The module was not explicitly or implicitly declared.

         */

        SYNTHETIC,

        /**

         * The module was implicitly declared.

         */

        MANDATED;

    }

    /**

     * <p> A dependence upon a module </p>

     *

     * @see ModuleDescriptor#requires()

     * @since 9

     * @spec JPMS

     */

    public final static class Requires

        implements Comparable<Requires>

    {

        /**

         * A modifier on a module dependence.

         *

         * @see Requires#modifiers()

         * @since 9

         * @spec JPMS

         */

        public static enum Modifier {

            /**

             * The dependence causes any module which depends on the <i>current

             * module</i> to have an implicitly declared dependence on the module

             * named by the {@code Requires}.

             */

            TRANSITIVE,

            /**

             * The dependence is mandatory in the static phase, during compilation,

             * but is optional in the dynamic phase, during execution.

             */

            STATIC,

            /**

             * The dependence was not explicitly or implicitly declared in the

             * source of the module declaration.

             */

            SYNTHETIC,

            /**

             * The dependence was implicitly declared in the source of the module

             * declaration.

             */

            MANDATED;

        }

        private final Set<Modifier> mods;

        private final String name;

        private final Version compiledVersion;

        private final String rawCompiledVersion;

        private Requires(Set<Modifier> ms, String mn, Version v, String vs) {

            assert v == null || vs == null;

            if (ms.isEmpty()) {

                ms = Collections.emptySet();

            } else {

                ms = Collections.unmodifiableSet(EnumSet.copyOf(ms));

            }

            this.mods = ms;

            this.name = mn;

            this.compiledVersion = v;

            this.rawCompiledVersion = vs;

        }

        private Requires(Set<Modifier> ms, String mn, Version v, boolean unused) {

            this.mods = ms;

            this.name = mn;

            this.compiledVersion = v;

            this.rawCompiledVersion = null;

        }

        /**

         * Returns the set of modifiers.

         *

         * @return A possibly-empty unmodifiable set of modifiers

         */

        public Set<Modifier> modifiers() {

            return mods;

        }

        /**

         * Return the module name.

         *

         * @return The module name

         */

        public String name() {

            return name;

        }

        /**

         * Returns the version of the module if recorded at compile-time.

         *

         * @return The version of the module if recorded at compile-time,

         *         or an empty {@code Optional} if no version was recorded or

         *         the version string recorded is {@linkplain Version#parse(String)

         *         unparseable}

         */

        public Optional<Version> compiledVersion() {

            return Optional.ofNullable(compiledVersion);

        }

        /**

         * Returns the string with the possibly-unparseable version of the module

         * if recorded at compile-time.

         *

         * @return The string containing the version of the module if recorded

         *         at compile-time, or an empty {@code Optional} if no version

         *         was recorded

         *

         * @see #compiledVersion()

         */

        public Optional<String> rawCompiledVersion() {

            if (compiledVersion != null) {

                return Optional.of(compiledVersion.toString());

            } else {

                return Optional.ofNullable(rawCompiledVersion);

            }

        }

        /**

         * Compares this module dependence to another.

         *

         * <p> Two {@code Requires} objects are compared by comparing their

         * module names lexicographically. Where the module names are equal

         * then the sets of modifiers are compared in the same way that

         * module modifiers are compared (see {@link ModuleDescriptor#compareTo

         * ModuleDescriptor.compareTo}). Where the module names are equal and

         * the set of modifiers are equal then the version of the modules

         * recorded at compile-time are compared. When comparing the versions

         * recorded at compile-time then a dependence that has a recorded

         * version is considered to succeed a dependence that does not have a

         * recorded version. If both recorded versions are {@linkplain

         * Version#parse(String) unparseable} then the {@linkplain

         * #rawCompiledVersion() raw version strings} are compared

         * lexicographically. </p>

         *

         * @param  that

         *         The module dependence to compare

         *

         * @return A negative integer, zero, or a positive integer if this module

         *         dependence is less than, equal to, or greater than the given

         *         module dependence

         */

        @Override

        public int compareTo(Requires that) {

            if (this == that) return 0;

            int c = this.name().compareTo(that.name());

            if (c != 0) return c;

            // modifiers

            long v1 = modsValue(this.modifiers());

            long v2 = modsValue(that.modifiers());

            c = Long.compare(v1, v2);

            if (c != 0) return c;

            // compiledVersion

            c = compare(this.compiledVersion, that.compiledVersion);

            if (c != 0) return c;

            // rawCompiledVersion

            c = compare(this.rawCompiledVersion, that.rawCompiledVersion);

            if (c != 0) return c;

            return 0;

        }

        /**

         * Tests this module dependence for equality with the given object.

         *

         * <p> If the given object is not a {@code Requires} then this method

         * returns {@code false}. Two module dependence objects are equal if

         * the module names are equal, set of modifiers are equal, and the

         * compiled version of both modules is equal or not recorded for

         * both modules. </p>

         *

         * <p> This method satisfies the general contract of the {@link

         * java.lang.Object#equals(Object) Object.equals} method. </p>

         *

         * @param   ob

         *          the object to which this object is to be compared

         *

         * @return  {@code true} if, and only if, the given object is a module

         *          dependence that is equal to this module dependence

         */

        @Override

        public boolean equals(Object ob) {

            if (!(ob instanceof Requires))

                return false;

            Requires that = (Requires)ob;

            return name.equals(that.name) && mods.equals(that.mods)

                    && Objects.equals(compiledVersion, that.compiledVersion)

                    && Objects.equals(rawCompiledVersion, that.rawCompiledVersion);

        }

        /**

         * Computes a hash code for this module dependence.

         *

         * <p> The hash code is based upon the module name, modifiers, and the

         * module version if recorded at compile time. It satisfies the general

         * contract of the {@link Object#hashCode Object.hashCode} method. </p>

         *

         * @return The hash-code value for this module dependence

         */

        @Override

        public int hashCode() {

            int hash = name.hashCode() * 43 + mods.hashCode();

            if (compiledVersion != null)

                hash = hash * 43 + compiledVersion.hashCode();

            if (rawCompiledVersion != null)

                hash = hash * 43 + rawCompiledVersion.hashCode();

            return hash;

        }

        /**

         * Returns a string describing this module dependence.

         *

         * @return A string describing this module dependence

         */

        @Override

        public String toString() {

            String what;

            if (compiledVersion != null) {

                what = name() + " (@" + compiledVersion + ")";

            } else {

                what = name();

            }

            return ModuleDescriptor.toString(mods, what);

        }

    }

    /**

     * <p> A package exported by a module, may be qualified or unqualified. </p>

     *

     * @see ModuleDescriptor#exports()

     * @since 9

     * @spec JPMS

     */

    public final static class Exports

        implements Comparable<Exports>

    {

        /**

         * A modifier on an exported package.

         *

         * @see Exports#modifiers()

         * @since 9

         * @spec JPMS

         */

        public static enum Modifier {

            /**

             * The export was not explicitly or implicitly declared in the

             * source of the module declaration.

             */

            SYNTHETIC,

            /**

             * The export was implicitly declared in the source of the module

             * declaration.

             */

            MANDATED;

        }

        private final Set<Modifier> mods;

        private final String source;

        private final Set<String> targets;  // empty if unqualified export

        /**

         * Constructs an export

         */

        private Exports(Set<Modifier> ms, String source, Set<String> targets) {

            if (ms.isEmpty()) {

                ms = Collections.emptySet();

            } else {

                ms = Collections.unmodifiableSet(EnumSet.copyOf(ms));

            }

            this.mods = ms;

            this.source = source;

            this.targets = emptyOrUnmodifiableSet(targets);

        }

        private Exports(Set<Modifier> ms,

                        String source,

                        Set<String> targets,

                        boolean unused) {

            this.mods = ms;

            this.source = source;

            this.targets = targets;

        }

        /**

         * Returns the set of modifiers.

         *

         * @return A possibly-empty unmodifiable set of modifiers

         */

        public Set<Modifier> modifiers() {

            return mods;

        }

        /**

         * Returns {@code true} if this is a qualified export.

         *

         * @return {@code true} if this is a qualified export

         */

        public boolean isQualified() {

            return !targets.isEmpty();

        }

        /**

         * Returns the package name.

         *

         * @return The package name

         */

        public String source() {

            return source;

        }

        /**

         * For a qualified export, returns the non-empty and immutable set

         * of the module names to which the package is exported. For an

         * unqualified export, returns an empty set.

         *

         * @return The set of target module names or for an unqualified

         *         export, an empty set

         */

        public Set<String> targets() {

            return targets;

        }

        /**

         * Compares this module export to another.

         *

         * <p> Two {@code Exports} objects are compared by comparing the package

         * names lexicographically. Where the packages names are equal then the

         * sets of modifiers are compared in the same way that module modifiers

         * are compared (see {@link ModuleDescriptor#compareTo

         * ModuleDescriptor.compareTo}). Where the package names are equal and

         * the set of modifiers are equal then the set of target modules are

         * compared. This is done by sorting the names of the target modules

         * in ascending order, and according to their natural ordering, and then

         * comparing the corresponding elements lexicographically. Where the

         * sets differ in size, and the larger set contains all elements of the

         * smaller set, then the larger set is considered to succeed the smaller

         * set. </p>

         *

         * @param  that

         *         The module export to compare

         *

         * @return A negative integer, zero, or a positive integer if this module

         *         export is less than, equal to, or greater than the given

         *         export dependence

         */

        @Override

        public int compareTo(Exports that) {

            if (this == that) return 0;

            int c = source.compareTo(that.source);

            if (c != 0)

                return c;

            // modifiers

            long v1 = modsValue(this.modifiers());

            long v2 = modsValue(that.modifiers());

            c = Long.compare(v1, v2);