/*

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

 *

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

 */

import java.io.File;

import java.io.IOException;

import java.io.UncheckedIOException;

import java.nio.file.DirectoryStream;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Deque;

import java.util.List;

import java.util.Set;

import java.util.concurrent.ConcurrentLinkedDeque;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import jdk.internal.jimage.BasicImageReader;

import jdk.internal.jimage.ImageLocation;

/*

 * @test

 * @summary Verify jimage

 * @modules java.base/jdk.internal.jimage

 * @run main/othervm --add-modules ALL-SYSTEM VerifyJimage

 */

/**

 * This test runs in two modes:

 * (1) No argument: it verifies the jimage by loading all classes in the runtime

 * (2) path of exploded modules: it compares bytes of each file in the exploded

 *     module with the entry in jimage

 *

 * FIXME: exception thrown when findLocation from jimage by multiple threads

 * -Djdk.test.threads=<n> to specify the number of threads.

 */

public class VerifyJimage {

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

    private static final Deque<String> failed = new ConcurrentLinkedDeque<>();

    public static void main(String... args) throws Exception {

        String home = System.getProperty("java.home");

        Path bootimagePath = Paths.get(home, "lib", "modules");

        if (Files.notExists(bootimagePath)) {

             System.out.println("Test skipped, not an images build");

             return;

        }

        long start = System.nanoTime();

        int numThreads = Integer.getInteger("jdk.test.threads", 1);

        JImageReader reader = newJImageReader();

        VerifyJimage verify = new VerifyJimage(reader, numThreads);

        if (args.length == 0) {

            // load classes from jimage

            verify.loadClasses();

        } else {

            Path dir = Paths.get(args[0]);

            if (Files.notExists(dir) || !Files.isDirectory(dir)) {

                throw new RuntimeException("Invalid argument: " + dir);

            }

            verify.compareExplodedModules(dir);

        }

        verify.waitForCompletion();

        long end = System.nanoTime();

        int entries = reader.entries();

        System.out.format("%d entries %d files verified: %d ms %d errors%n",

                          entries, verify.count.get(),

                          TimeUnit.NANOSECONDS.toMillis(end - start), failed.size());

        for (String f : failed) {

            System.err.println(f);

        }

        if (!failed.isEmpty()) {

            throw new AssertionError("Test failed");

        }

    }

    private final AtomicInteger count = new AtomicInteger(0);

    private final JImageReader reader;

    private final ExecutorService pool;

    VerifyJimage(JImageReader reader, int numThreads) {

        this.reader = reader;

        this.pool = Executors.newFixedThreadPool(numThreads);

    }

    private void waitForCompletion() throws InterruptedException {

        pool.shutdown();

        pool.awaitTermination(20, TimeUnit.SECONDS);

    }

    private void compareExplodedModules(Path dir) throws IOException {

        System.out.println("comparing jimage with " + dir);

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

            for (Path mdir : stream) {

                if (Files.isDirectory(mdir)) {

                    pool.execute(new Runnable() {

                        @Override

                        public void run() {

                            try {

                                Files.find(mdir, Integer.MAX_VALUE, (Path p, BasicFileAttributes attr)

                                           -> !Files.isDirectory(p) &&

                                              !mdir.relativize(p).toString().startsWith("_") &&

                                              !p.getFileName().toString().equals("MANIFEST.MF"))

                                     .forEach(p -> compare(mdir, p, reader));

                            } catch (IOException e) {

                                throw new UncheckedIOException(e);

                            }

                        }

                    });

                }

            }

        }

    }

    private final List<String> BOOT_RESOURCES = Arrays.asList(

        "java.base/META-INF/services/java.nio.file.spi.FileSystemProvider"

    );

    private final List<String> EXT_RESOURCES = Arrays.asList(

        "jdk.zipfs/META-INF/services/java.nio.file.spi.FileSystemProvider"

    );

    private final List<String> APP_RESOURCES = Arrays.asList(

        "jdk.hotspot.agent/META-INF/services/com.sun.jdi.connect.Connector",

        "jdk.jdi/META-INF/services/com.sun.jdi.connect.Connector"

    );

    private void compare(Path mdir, Path p, JImageReader reader) {

        String entry = p.getFileName().toString().equals(MODULE_INFO)

                ? mdir.getFileName().toString() + "/" + MODULE_INFO

                : mdir.relativize(p).toString().replace(File.separatorChar, '/');

        count.incrementAndGet();

        String file = mdir.getFileName().toString() + "/" + entry;

        if (APP_RESOURCES.contains(file)) {

            // skip until the service config file is merged

            System.out.println("Skipped " + file);

            return;

        }

        if (reader.findLocation(entry) != null) {

            reader.compare(entry, p);

        }

    }

    private void loadClasses() {

        ClassLoader loader = ClassLoader.getSystemClassLoader();

        Stream.of(reader.getEntryNames())

              .filter(this::accept)

              .map(this::toClassName)

              .forEach(cn -> {

                  count.incrementAndGet();

                  try {

                      System.out.println("Loading " + cn);

                      Class.forName(cn, false, loader);

                  } catch (VerifyError ve) {

                      System.err.println("VerifyError for " + cn);

                      failed.add(reader.imageName() + ": " + cn + " not verified: " + ve.getMessage());

                  } catch (ClassNotFoundException e) {

                      failed.add(reader.imageName() + ": " + cn + " not found");

                  }

              });

    }

    private String toClassName(String entry) {

        int index = entry.indexOf('/', 1);

        return entry.substring(index + 1, entry.length())

                    .replaceAll("\\.class$", "").replace('/', '.');

    }

    private static Set<String> EXCLUDED_MODULES =

        Set.of("javafx.deploy", "jdk.deploy", "jdk.plugin", "jdk.javaws",

            // All JVMCI packages other than jdk.vm.ci.services are dynamically

            // exported to jdk.internal.vm.compiler and jdk.aot

            "jdk.internal.vm.compiler", "jdk.aot"

        );

    private boolean accept(String entry) {

        int index = entry.indexOf('/', 1);

        String mn = index > 1 ? entry.substring(1, index) : "";

        // filter deployment modules

        if (mn.isEmpty() || EXCLUDED_MODULES.contains(mn)) {

            return false;

        }

        return entry.endsWith(".class") && !entry.endsWith(MODULE_INFO);

    }

    private static JImageReader newJImageReader() throws IOException {

        String home = System.getProperty("java.home");

        Path jimage = Paths.get(home, "lib", "modules");

        System.out.println("opened " + jimage);

        return new JImageReader(jimage);

    }

    static class JImageReader extends BasicImageReader {

        final Path jimage;

        JImageReader(Path p) throws IOException {

            super(p);

            this.jimage = p;

        }

        String imageName() {

            return jimage.getFileName().toString();

        }

        int entries() {

            return getHeader().getTableLength();

        }

        void compare(String entry, Path p) {

            try {

                byte[] bytes = Files.readAllBytes(p);

                byte[] imagebytes = getResource(entry);

                if (!Arrays.equals(bytes, imagebytes)) {

                    failed.add(imageName() + ": bytes differs than " + p.toString());

                }

            } catch (IOException e) {

                throw new UncheckedIOException(e);

            }

        }

    }

}