/*

 * Copyright (c) 2014, 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 jdk.internal.module;

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.UncheckedIOException;

import java.lang.module.FindException;

import java.lang.module.InvalidModuleDescriptorException;

import java.lang.module.ModuleDescriptor;

import java.lang.module.ModuleFinder;

import java.lang.module.ModuleReference;

import java.net.URI;

import java.nio.file.DirectoryStream;

import java.nio.file.Files;

import java.nio.file.NoSuchFileException;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Optional;

import java.util.Set;

import java.util.jar.Attributes;

import java.util.jar.JarEntry;

import java.util.jar.JarFile;

import java.util.jar.Manifest;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.zip.ZipFile;

import jdk.internal.jmod.JmodFile;

import jdk.internal.jmod.JmodFile.Section;

import jdk.internal.perf.PerfCounter;

import jdk.internal.util.jar.VersionedStream;

/**

 * A {@code ModuleFinder} that locates modules on the file system by searching

 * a sequence of directories or packaged modules. The ModuleFinder can be

 * created to work in either the run-time or link-time phases. In both cases it

 * locates modular JAR and exploded modules. When created for link-time then it

 * additionally locates modules in JMOD files. The ModuleFinder can also

 * optionally patch any modules that it locates with a ModulePatcher.

 */

public class ModulePath implements ModuleFinder {

    private static final String MODULE_INFO = "module-info.class";

    // the version to use for multi-release modular JARs

    private final Runtime.Version releaseVersion;

    // true for the link phase (supports modules packaged in JMOD format)

    private final boolean isLinkPhase;

    // for patching modules, can be null

    private final ModulePatcher patcher;

    // the entries on this module path

    private final Path[] entries;

    private int next;

    // map of module name to module reference map for modules already located

    private final Map<String, ModuleReference> cachedModules = new HashMap<>();

    private ModulePath(Runtime.Version version,

                       boolean isLinkPhase,

                       ModulePatcher patcher,

                       Path... entries) {

        this.releaseVersion = version;

        this.isLinkPhase = isLinkPhase;

        this.patcher = patcher;

        this.entries = entries.clone();

        for (Path entry : this.entries) {

            Objects.requireNonNull(entry);

        }

    }

    /**

     * Returns a ModuleFinder that that locates modules on the file system by

     * searching a sequence of directories and/or packaged modules. The modules

     * may be patched by the given ModulePatcher.

     */

    public static ModuleFinder of(ModulePatcher patcher, Path... entries) {

        return new ModulePath(JarFile.runtimeVersion(), false, patcher, entries);

    }

    /**

     * Returns a ModuleFinder that that locates modules on the file system by

     * searching a sequence of directories and/or packaged modules.

     */

    public static ModuleFinder of(Path... entries) {

        return of((ModulePatcher)null, entries);

    }

    /**

     * Returns a ModuleFinder that that locates modules on the file system by

     * searching a sequence of directories and/or packaged modules.

     *

     * @param version The release version to use for multi-release JAR files

     * @param isLinkPhase {@code true} if the link phase to locate JMOD files

     */

    public static ModuleFinder of(Runtime.Version version,

                                  boolean isLinkPhase,

                                  Path... entries) {

        return new ModulePath(version, isLinkPhase, null, entries);

    }

    @Override

    public Optional<ModuleReference> find(String name) {

        Objects.requireNonNull(name);

        // try cached modules

        ModuleReference m = cachedModules.get(name);

        if (m != null)

            return Optional.of(m);

        // the module may not have been encountered yet

        while (hasNextEntry()) {

            scanNextEntry();

            m = cachedModules.get(name);

            if (m != null)

                return Optional.of(m);

        }

        return Optional.empty();

    }

    @Override

    public Set<ModuleReference> findAll() {

        // need to ensure that all entries have been scanned

        while (hasNextEntry()) {

            scanNextEntry();

        }

        return cachedModules.values().stream().collect(Collectors.toSet());

    }

    /**

     * Returns {@code true} if there are additional entries to scan

     */

    private boolean hasNextEntry() {

        return next < entries.length;

    }

    /**

     * Scans the next entry on the module path. A no-op if all entries have

     * already been scanned.

     *

     * @throws FindException if an error occurs scanning the next entry

     */

    private void scanNextEntry() {

        if (hasNextEntry()) {

            long t0 = System.nanoTime();

            Path entry = entries[next];

            Map<String, ModuleReference> modules = scan(entry);

            next++;

            // update cache, ignoring duplicates

            int initialSize = cachedModules.size();

            for (Map.Entry<String, ModuleReference> e : modules.entrySet()) {

                cachedModules.putIfAbsent(e.getKey(), e.getValue());

            }

            // update counters

            int added = cachedModules.size() - initialSize;

            moduleCount.add(added);

            scanTime.addElapsedTimeFrom(t0);

        }

    }

    /**

     * Scan the given module path entry. If the entry is a directory then it is

     * a directory of modules or an exploded module. If the entry is a regular

     * file then it is assumed to be a packaged module.

     *

     * @throws FindException if an error occurs scanning the entry

     */

    private Map<String, ModuleReference> scan(Path entry) {

        BasicFileAttributes attrs;

        try {

            attrs = Files.readAttributes(entry, BasicFileAttributes.class);

        } catch (NoSuchFileException e) {

            return Collections.emptyMap();

        } catch (IOException ioe) {

            throw new FindException(ioe);

        }

        try {

            if (attrs.isDirectory()) {

                Path mi = entry.resolve(MODULE_INFO);

                if (!Files.exists(mi)) {

                    // assume a directory of modules

                    return scanDirectory(entry);

                }

            }

            // packaged or exploded module

            ModuleReference mref = readModule(entry, attrs);

            if (mref != null) {

                String name = mref.descriptor().name();

                return Collections.singletonMap(name, mref);

            }

            // not recognized

            String msg;

            if (!isLinkPhase && entry.toString().endsWith(".jmod")) {

                msg = "JMOD format not supported at execution time";

            } else {

                msg = "Module format not recognized";

            }

            throw new FindException(msg + ": " + entry);

        } catch (IOException ioe) {

            throw new FindException(ioe);

        }

    }

    /**

     * Scans the given directory for packaged or exploded modules.

     *

     * @return a map of module name to ModuleReference for the modules found

     *         in the directory

     *

     * @throws IOException if an I/O error occurs

     * @throws FindException if an error occurs scanning the entry or the

     *         directory contains two or more modules with the same name

     */

    private Map<String, ModuleReference> scanDirectory(Path dir)

        throws IOException

    {

        // The map of name -> mref of modules found in this directory.

        Map<String, ModuleReference> nameToReference = new HashMap<>();

        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {

            for (Path entry : stream) {

                BasicFileAttributes attrs;

                try {

                    attrs = Files.readAttributes(entry, BasicFileAttributes.class);

                } catch (NoSuchFileException ignore) {

                    // file has been removed or moved, ignore for now

                    continue;

                }

                ModuleReference mref = readModule(entry, attrs);

                // module found

                if (mref != null) {

                    // can have at most one version of a module in the directory

                    String name = mref.descriptor().name();

                    ModuleReference previous = nameToReference.put(name, mref);

                    if (previous != null) {

                        String fn1 = fileName(mref);

                        String fn2 = fileName(previous);

                        throw new FindException("Two versions of module "

                                                 + name + " found in " + dir

                                                 + " (" + fn1 + " and " + fn2 + ")");

                    }

                }

            }

        }

        return nameToReference;

    }

    /**

     * Reads a packaged or exploded module, returning a {@code ModuleReference}

     * to the module. Returns {@code null} if the entry is not recognized.

     *

     * @throws IOException if an I/O error occurs

     * @throws FindException if an error occurs parsing its module descriptor

     */

    private ModuleReference readModule(Path entry, BasicFileAttributes attrs)

        throws IOException

    {

        try {

            if (attrs.isDirectory()) {

                return readExplodedModule(entry); // may return null

                String fn = entry.getFileName().toString();

                        return readJar(entry);

                    }

                }

            }

        } catch (InvalidModuleDescriptorException e) {

            throw new FindException("Error reading module: " + entry, e);

        }

    }

    /**

     * Returns a string with the file name of the module if possible.

     * If the module location is not a file URI then return the URI

     * as a string.

     */

    private String fileName(ModuleReference mref) {

        URI uri = mref.location().orElse(null);

        if (uri != null) {

            if (uri.getScheme().equalsIgnoreCase("file")) {

                Path file = Paths.get(uri);

                return file.getFileName().toString();

            } else {

                return uri.toString();

            }

        } else {

            return "<unknown>";

        }

    }

    // -- JMOD files --

    private Set<String> jmodPackages(JmodFile jf) {

        return jf.stream()

            .filter(e -> e.section() == Section.CLASSES)

            .map(JmodFile.Entry::name)

            .map(this::toPackageName)

            .flatMap(Optional::stream)

            .collect(Collectors.toSet());

    }

    /**

     * Returns a {@code ModuleReference} to a module in JMOD file on the

     * file system.

     *

     * @throws IOException

     * @throws InvalidModuleDescriptorException

     */

    private ModuleReference readJMod(Path file) throws IOException {

        try (JmodFile jf = new JmodFile(file)) {

            ModuleInfo.Attributes attrs;

            try (InputStream in = jf.getInputStream(Section.CLASSES, MODULE_INFO)) {

                attrs  = ModuleInfo.read(in, () -> jmodPackages(jf));

            }

            return ModuleReferences.newJModModule(attrs, file);

        }

    }

    // -- JAR files --

    private static final String SERVICES_PREFIX = "META-INF/services/";

    /**

     * Returns the service type corresponding to the name of a services

     * configuration file if it is a legal type name.

     *

     * For example, if called with "META-INF/services/p.S" then this method

     * returns a container with the value "p.S".

     */

    private Optional<String> toServiceName(String cf) {

        assert cf.startsWith(SERVICES_PREFIX);

        int index = cf.lastIndexOf("/") + 1;

        if (index < cf.length()) {

            String prefix = cf.substring(0, index);

            if (prefix.equals(SERVICES_PREFIX)) {

                String sn = cf.substring(index);

                if (Checks.isClassName(sn))

                    return Optional.of(sn);

            }

        }

        return Optional.empty();

    }

    /**

     * Reads the next line from the given reader and trims it of comments and

     * leading/trailing white space.

     *

     * Returns null if the reader is at EOF.

     */

    private String nextLine(BufferedReader reader) throws IOException {

        String ln = reader.readLine();

        if (ln != null) {

            int ci = ln.indexOf('#');

            if (ci >= 0)

                ln = ln.substring(0, ci);

            ln = ln.trim();

        }

        return ln;

    }

    /**

     * Treat the given JAR file as a module as follows:

     *

     * 1. The module name (and optionally the version) is derived from the file

     *    name of the JAR file

     * 2. All packages are derived from the .class files in the JAR file

     * 3. The contents of any META-INF/services configuration files are mapped

     *    to "provides" declarations

     * 4. The Main-Class attribute in the main attributes of the JAR manifest

     */

    private ModuleDescriptor deriveModuleDescriptor(JarFile jf)

        throws IOException

    {

        // Derive module name and version from JAR file name

        String fn = jf.getName();

        int i = fn.lastIndexOf(File.separator);

        if (i != -1)

            fn = fn.substring(i+1);

        // drop .jar

        String mn = fn.substring(0, fn.length()-4);

        String vs = null;

        // find first occurrence of -${NUMBER}. or -${NUMBER}$

        Matcher matcher = Patterns.DASH_VERSION.matcher(mn);

        if (matcher.find()) {

            int start = matcher.start();

            // attempt to parse the tail as a version string

            try {

                String tail = mn.substring(start+1);

                ModuleDescriptor.Version.parse(tail);

                vs = tail;

            } catch (IllegalArgumentException ignore) { }

            mn = mn.substring(0, start);

        }

        // finally clean up the module name

        mn = cleanModuleName(mn);

        // Builder throws IAE if module name is empty or invalid

        ModuleDescriptor.Builder builder = ModuleDescriptor.newAutomaticModule(mn);

        if (vs != null)

            builder.version(vs);

        // scan the names of the entries in the JAR file

        Map<Boolean, Set<String>> map = VersionedStream.stream(jf)

                .filter(e -> !e.isDirectory())

                .map(JarEntry::getName)

                .filter(e -> (e.endsWith(".class") ^ e.startsWith(SERVICES_PREFIX)))

                .collect(Collectors.partitioningBy(e -> e.startsWith(SERVICES_PREFIX),

                                                   Collectors.toSet()));

        Set<String> classFiles = map.get(Boolean.FALSE);

        Set<String> configFiles = map.get(Boolean.TRUE);

        // the packages containing class files

        Set<String> packages = classFiles.stream()

                .map(this::toPackageName)

                .flatMap(Optional::stream)

                .distinct()

                .collect(Collectors.toSet());

        // all packages are exported and open

        builder.packages(packages);

        // map names of service configuration files to service names

        Set<String> serviceNames = configFiles.stream()

                .map(this::toServiceName)

                .flatMap(Optional::stream)