/*

 * Copyright (c) 2018, 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.File;

import java.io.IOException;

import java.io.PrintStream;

import java.lang.module.FindException;

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.attribute.BasicFileAttributes;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Map;

import java.util.Optional;

import java.util.stream.Stream;

/**

 * A validator to check for errors and conflicts between modules.

 */

class ModulePathValidator {

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

    private static final String INDENT = "    ";

    private final Map<String, ModuleReference> nameToModule;

    private final Map<String, ModuleReference> packageToModule;

    private final PrintStream out;

    private int errorCount;

    private ModulePathValidator(PrintStream out) {

        this.nameToModule = new HashMap<>();

        this.packageToModule = new HashMap<>();

        this.out = out;

    }

    /**

     * Scans and the validates all modules on the module path. The module path

     * comprises the upgrade module path, system modules, and the application

     * module path.

     *

     * @param out the print stream for output messages

     * @return the number of errors found

     */

    static int scanAllModules(PrintStream out) {

        ModulePathValidator validator = new ModulePathValidator(out);

        // upgrade module path

        String value = System.getProperty("jdk.module.upgrade.path");

        if (value != null) {

            Stream.of(value.split(File.pathSeparator))

                    .map(Path::of)

                    .forEach(validator::scan);

        }

        // system modules

        ModuleFinder.ofSystem().findAll().stream()

                .sorted(Comparator.comparing(ModuleReference::descriptor))

                .forEach(validator::process);

        // application module path

        value = System.getProperty("jdk.module.path");

        if (value != null) {

            Stream.of(value.split(File.pathSeparator))

                    .map(Path::of)

                    .forEach(validator::scan);

        }

        return validator.errorCount;

    }

    /**

     * Prints the module location and name.

     */

    private void printModule(ModuleReference mref) {

        mref.location()

                .filter(uri -> !isJrt(uri))

                .ifPresent(uri -> out.print(uri + " "));

        ModuleDescriptor descriptor = mref.descriptor();

        out.print(descriptor.name());

        if (descriptor.isAutomatic())

            out.print(" automatic");

        out.println();

    }

    /**

     * Prints the module location and name, checks if the module is

     * shadowed by a previously seen module, and finally checks for

     * package conflicts with previously seen modules.

     */

    private void process(ModuleReference mref) {

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

        ModuleReference previous = nameToModule.putIfAbsent(name, mref);

        if (previous != null) {

            printModule(mref);

            out.print(INDENT + "shadowed by ");

            printModule(previous);

        } else {

            boolean first = true;

            // check for package conflicts when not shadowed

            for (String pkg :  mref.descriptor().packages()) {

                previous = packageToModule.putIfAbsent(pkg, mref);

                if (previous != null) {

                    if (first) {

                        printModule(mref);

                        first = false;

                        errorCount++;

                    }

                    String mn = previous.descriptor().name();

                    out.println(INDENT + "contains " + pkg

                            + " conflicts with module " + mn);

                }

            }

        }

    }

    /**

     * Scan an element on a module path. The element is a directory

     * of modules, an exploded module, or a JAR file.

     */

    private void scan(Path entry) {

        BasicFileAttributes attrs;

        try {

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

        } catch (NoSuchFileException ignore) {

            return;

        } catch (IOException ioe) {

            out.println(entry + " " + ioe);

            errorCount++;

            return;

        }

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

        if (attrs.isRegularFile() && fn.endsWith(".jar")) {

            // JAR file, explicit or automatic module

            scanModule(entry).ifPresent(this::process);

        } else if (attrs.isDirectory()) {

            Path mi = entry.resolve(MODULE_INFO);

            if (Files.exists(mi)) {

                // exploded module

                scanModule(entry).ifPresent(this::process);

            } else {

                // directory of modules

                scanDirectory(entry);

            }

        }

    }

    /**

     * Scan the JAR files and exploded modules in a directory.

     */

    private void scanDirectory(Path dir) {

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

            Map<String, Path> moduleToEntry = new HashMap<>();

            for (Path entry : stream) {

                BasicFileAttributes attrs;

                try {

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

                } catch (IOException ioe) {

                    out.println(entry + " " + ioe);

                    errorCount++;

                    continue;

                }

                ModuleReference mref = null;

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

                if (attrs.isRegularFile() && fn.endsWith(".jar")) {

                    mref = scanModule(entry).orElse(null);

                } else if (attrs.isDirectory()) {

                    Path mi = entry.resolve(MODULE_INFO);

                    if (Files.exists(mi)) {

                        mref = scanModule(entry).orElse(null);

                    }

                }

                if (mref != null) {

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

                    Path previous = moduleToEntry.putIfAbsent(name, entry);

                    if (previous != null) {

                        // same name as other module in the directory

                        printModule(mref);

                        out.println(INDENT + "contains same module as "

                                + previous.getFileName());

                        errorCount++;

                    } else {

                        process(mref);

                    }

                }

            }

        } catch (IOException ioe) {

            out.println(dir + " " + ioe);

            errorCount++;

        }

    }

    /**

     * Scan a JAR file or exploded module.

     */

    private Optional<ModuleReference> scanModule(Path entry) {

        ModuleFinder finder = ModuleFinder.of(entry);

        try {

            return finder.findAll().stream().findFirst();

        } catch (FindException e) {

            out.println(entry);

            out.println(INDENT + e.getMessage());

            Throwable cause = e.getCause();

            if (cause != null) {

                out.println(INDENT + cause);

            }

            errorCount++;

            return Optional.empty();

        }

    }

    /**

     * Returns true if the given URI is a jrt URI

     */

    private static boolean isJrt(URI uri) {

        return (uri != null && uri.getScheme().equalsIgnoreCase("jrt"));

    }

}