/*

 * Copyright (c) 2015, 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.

 */

package tests;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.nio.file.Files;

import java.nio.file.Path;

import java.util.ArrayList;

import java.util.List;

import java.util.Properties;

import com.sun.tools.classfile.ClassFile;

import com.sun.tools.classfile.ConstantPoolException;

import jdk.internal.jimage.BasicImageReader;

import jdk.internal.jimage.ImageLocation;

/**

 *

 * JDK Modular image validator

 */

public class JImageValidator {

    private static final String[] dirs = {"bin", "lib"};

    private final File rootDir;

    private final List<String> expectedLocations;

    private final String module;

    private long moduleExecutionTime;

    private long javaExecutionTime;

    private final List<String> unexpectedPaths;

    private final List<String> unexpectedFiles;

    private final String[] expectedFiles;

    public JImageValidator(String module, List<String> expectedLocations,

            File rootDir,

            List<String> unexpectedPaths,

            List<String> unexpectedFiles) throws Exception {

        this(module, expectedLocations, rootDir, unexpectedPaths, unexpectedFiles, null);

    }

    public JImageValidator(String module, List<String> expectedLocations,

            File rootDir,

            List<String> unexpectedPaths,

            List<String> unexpectedFiles,

            String[] expectedFiles) throws IOException {

        if (!rootDir.exists()) {

            throw new IOException("Image root dir not found " +

                    rootDir.getAbsolutePath());

        }

        this.expectedLocations = expectedLocations;

        this.rootDir = rootDir;

        this.module = module;

        this.unexpectedPaths = unexpectedPaths;

        this.unexpectedFiles = unexpectedFiles;

        this.expectedFiles = expectedFiles == null ? new String[0] : expectedFiles;

    }

    public void validate() throws IOException {

        for (String d : dirs) {

            File dir = new File(rootDir, d);

            if (!dir.isDirectory()) {

                throw new IOException("Invalid directory " + d);

            }

        }

        //check jimage file

        Path path = rootDir.toPath().resolve("lib").resolve("modules");

        if (!Files.isRegularFile(path)) {

            throw new IOException(path + " No jimage file generated");

        }

        // Check binary file

        File launcher = new File(rootDir, "bin" + File.separator + module);

        if (launcher.exists()) {

            ProcessBuilder builder = new ProcessBuilder("sh", launcher.getAbsolutePath());

            long t = System.currentTimeMillis();

            Process process = builder.inheritIO().start();

            int ret = waitFor(process);

            moduleExecutionTime += System.currentTimeMillis() - t;

            if (ret != 0) {

                throw new IOException("Image " + module + " execution failed, check logs.");

            }

        }

        for (String f : expectedFiles) {

            File dd = new File(rootDir, f);

            if (!dd.exists()) {

                throw new IOException("Expected File " + f + " not found");

            }

        }

        //Walk and check that unexpected files are not there

        try (java.util.stream.Stream<Path> stream = Files.walk(rootDir.toPath())) {

            stream.forEach((p) -> {

                for (String u : unexpectedFiles) {

                    if (p.toString().equals(u)) {

                        throw new RuntimeException("Seen unexpected path " + p);

                    }

                }

            });

        }

        File javaLauncher = new File(rootDir, "bin" + File.separator +

                (isWindows() ? "java.exe" : "java"));

        if (javaLauncher.exists()) {

            ProcessBuilder builder = new ProcessBuilder(javaLauncher.getAbsolutePath(),

                    "-version");

            long t = System.currentTimeMillis();

            Process process = builder.start();

            int ret = waitFor(process);

            javaExecutionTime += System.currentTimeMillis() - t;

            if (ret != 0) {

                throw new RuntimeException("java launcher execution failed, check logs.");

            }

        } else {

            throw new IOException("java launcher not found.");

        }

        // Check release file

        File release = new File(rootDir, "release");

        if (!release.exists()) {

            throw new IOException("Release file not generated");

        } else {

            Properties props = new Properties();

            try (FileInputStream fs = new FileInputStream(release)) {

                props.load(fs);

                String s = props.getProperty("MODULES");

                if (s == null) {

                    throw new IOException("No MODULES property in release");

                }

                if (!s.contains(module)) {

                    throw new IOException("Module not found in release file " + s);

                }

            }

        }

    }

    private int waitFor(Process process) {

        try {

            return process.waitFor();

        } catch (InterruptedException e) {

            throw new RuntimeException(e);

        }

    }

    private static boolean isWindows() {

        return System.getProperty("os.name").startsWith("Windows");

    }

    public static void validate(Path jimage, List<String> expectedLocations,

            List<String> unexpectedPaths) throws IOException {

        BasicImageReader reader = BasicImageReader.open(jimage);

        // Validate expected locations

        List<String> seenLocations = new ArrayList<>();

        for (String loc : expectedLocations) {

            ImageLocation il = reader.findLocation(loc);

            if (il == null) {

                throw new IOException("Location " + loc + " not present in " + jimage);

            }

        }

        seenLocations.addAll(expectedLocations);

        for (String s : reader.getEntryNames()) {

            if (s.endsWith(".class") && !s.endsWith("module-info.class")) {

                ImageLocation il = reader.findLocation(s);

                try {

                    byte[] r = reader.getResource(il);

                    if(r == null) {

                        System.out.println("IL, compressed " +

                                il.getCompressedSize() + " uncompressed " +

                                il.getUncompressedSize());

                        throw new IOException("NULL RESOURCE " + s);

                    }

                    readClass(r);

                } catch (IOException ex) {

                    System.err.println(s + " ERROR " + ex);

                    throw ex;

                }

            }

            if (seenLocations.contains(s)) {

                seenLocations.remove(s);

            }

            for(String p : unexpectedPaths) {

                if (s.equals(p)) {

                    throw new IOException("Seen unexpected path " + s);

                }

            }

        }

        if (!seenLocations.isEmpty()) {

            throw new IOException("ImageReader did not return " + seenLocations);

        }

    }

    public long getJavaLauncherExecutionTime() {

        return javaExecutionTime;

    }

    public long getModuleLauncherExecutionTime() {

        return moduleExecutionTime;

    }

    public static void readClass(byte[] clazz) throws IOException {

        try (InputStream stream = new ByteArrayInputStream(clazz)) {

            ClassFile.read(stream);

        } catch (ConstantPoolException e) {

            throw new IOException(e);

        }

    }

}