/*

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

import java.net.URI;

import java.nio.file.DirectoryStream;

import java.nio.file.FileSystems;

import java.nio.file.Files;

import java.nio.file.Path;

import java.util.Arrays;

import java.util.EnumSet;

import java.util.List;

import javax.lang.model.element.TypeElement;

import javax.tools.Diagnostic;

import javax.tools.DiagnosticListener;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.StandardLocation;

import javax.tools.ToolProvider;

public class ExplodedImage {

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

        new ExplodedImage().run(args);

    }

    void run(String... args) throws IOException {

        switch (args[0]) {

            case "testDirectoryStreamClosed":

                testDirectoryStreamClosed(args[1]);

                break;

            case "testCanCompileAgainstExplodedImage":

                testCanCompileAgainstExplodedImage(args[1]);

                break;

        }

    }

    void testDirectoryStreamClosed(String loc) throws IOException {

        System.err.println("testDirectoryStreamClosed(" + loc + ")");

        Path javaHome = prepareJavaHome();

        Path targetPath = javaHome.resolve(loc.replace("*", "/java.base").replace("/", sep));

        Path testClass = targetPath.resolve(("java/lang/" + TEST_FILE).replace("/", sep));

        Files.createDirectories(testClass.getParent());

        Files.createFile(testClass);

        System.setProperty("java.home", javaHome.toString());

        for (int i = 0; i < REPEATS; i++) {

            try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {

                Iterable<JavaFileObject> javaLangContent =

                        fm.list(StandardLocation.PLATFORM_CLASS_PATH,

                                "java.lang",

                                EnumSet.allOf(JavaFileObject.Kind.class),

                                false);

                boolean found = false;

                for (JavaFileObject fo : javaLangContent) {

                    if (!fo.getName().endsWith(TEST_FILE)) {

                        throw new IllegalStateException("Wrong file: " + fo);

                    }

                    found = true;

                }

                if (!found)

                    throw new IllegalStateException("Could not find the expected file!");

            }

        }

        System.err.println("finished.");

    }

    //where:

        static final String TEST_FILE = "ExplodedImageTestFile.class";

        static final int REPEATS = 16 * 1024 + 1;

    void testCanCompileAgainstExplodedImage(String loc) throws IOException {

        System.err.println("testCanCompileAgainstExplodedImage(" + loc + ")");

        Path javaHome = prepareJavaHome();

        Path targetPath = javaHome.resolve(loc.replace("*", "/java.base").replace("/", sep));

        try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {

            for (String pack : REQUIRED_PACKAGES) {

                Iterable<JavaFileObject> content = fm.list(StandardLocation.PLATFORM_CLASS_PATH,

                                                           pack,

                                                           EnumSet.allOf(JavaFileObject.Kind.class),

                                                           false);

                for (JavaFileObject jfo : content) {

                    String name = jfo.getName();

                    int lastSlash = name.lastIndexOf('/');

                    name = lastSlash >= 0 ? name.substring(lastSlash + 1) : name;

                    Path target = targetPath.resolve(pack.replace(".", sep) + sep + name);

                    Files.createDirectories(target.getParent());

                    try (InputStream in = jfo.openInputStream()) {

                        Files.copy(in, target);

                    }

                }

            }

        }

        System.setProperty("java.home", javaHome.toString());

        try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {

            DiagnosticListener<JavaFileObject> noErrors = d -> {

                if (d.getKind() == Diagnostic.Kind.ERROR)

                    throw new IllegalStateException("Unexpected error: " + d);

            };

            ToolBox.JavaSource inputFile =

                    new ToolBox.JavaSource("import java.util.List; class Test { List l; }");

            List<JavaFileObject> inputFiles = Arrays.asList(inputFile);

            boolean result =

                    javaCompiler.getTask(null, fm, noErrors, null, null, inputFiles).call();

            if (!result) {

                throw new IllegalStateException("Could not compile correctly!");

            }

            JavacTask task =

                    (JavacTask) javaCompiler.getTask(null, fm, noErrors, null, null, inputFiles);

            task.parse();

            TypeElement juList = task.getElements().getTypeElement("java.util.List");

            if (juList == null)

                throw new IllegalStateException("Cannot resolve java.util.List!");

            URI listSource = ((ClassSymbol) juList).classfile.toUri();

            if (!listSource.toString().startsWith(javaHome.toUri().toString()))

                throw new IllegalStateException(  "Did not load java.util.List from correct place, " +

                                                  "actual location: " + listSource.toString() +

                                                "; expected prefix: " + javaHome.toUri());

        }

        System.err.println("finished.");

    }

    //where:

        static final String[] REQUIRED_PACKAGES = {"java.lang", "java.io", "java.util"};

    Path prepareJavaHome() throws IOException {

        Path javaHome = new File("javahome").getAbsoluteFile().toPath();

        delete(javaHome);

        Files.createDirectory(javaHome);

        return javaHome;

    }

    String sep = FileSystems.getDefault().getSeparator();

    JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();

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

    void delete(Path p) throws IOException {

        if (!Files.exists(p))

            return ;

        if (Files.isDirectory(p)) {

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

                for (Path child : dir) {

                    delete(child);

                }

            }

        }

        Files.delete(p);

    }

}