/*

 * Copyright (c) 2012, 2014, 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 com.sun.tools.jdeps;

import com.sun.tools.classfile.Annotation;

import com.sun.tools.classfile.ClassFile;

import com.sun.tools.classfile.ConstantPool;

import com.sun.tools.classfile.ConstantPoolException;

import com.sun.tools.classfile.RuntimeAnnotations_attribute;

import com.sun.tools.classfile.Dependencies.ClassFileError;

import java.io.IOException;

import java.io.InputStream;

import java.io.BufferedInputStream;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.*;

import java.util.jar.*;

import static com.sun.tools.classfile.Attribute.*;

import static com.sun.tools.jdeps.ClassFileReader.*;

/**

 * ClassPath for Java SE and JDK

 */

class PlatformClassPath {

    private static List<Archive> modules;

    static synchronized List<Archive> getArchives(Path mpath) throws IOException {

        if (modules == null) {

            initPlatformArchives(mpath);

        }

        return modules;

    }

    /**

     * Finds the module with the given name. Returns null

     * if such module doesn't exist.

     *

     * @param mn module name

     */

    static Module findModule(String mn) {

        for (Archive a : modules) {

            if (Module.class.isInstance(a)) {

                Module m = (Module)a;

                if (mn.equals(m.name())) {

                    return m;

                }

            }

        }

        return null;

    }

    private static List<Archive> initPlatformArchives(Path mpath) throws IOException {

        Path home = Paths.get(System.getProperty("java.home"));

        if (mpath == null && !home.endsWith("jre")) {

            // jdk build

            Path p = home.resolve("modules");

            if (Files.isDirectory(p)) {

                mpath = p;

            }

        }

        modules = mpath != null ? initModules(mpath) : initLegacyImage(home);

        if (findModule("java.base") != null) {

            Profile.initProfiles();

        }

        return modules;

    }

    private static List<Archive> initModules(Path mpath) throws IOException {

        String fn = System.getProperty("jdeps.modules.xml");

        if (fn!= null) {

            Path p = Paths.get(fn);

            try (InputStream in = new BufferedInputStream(Files.newInputStream(p))) {

                return new ArrayList<Archive>(ModulesXmlReader.load(mpath, in));

            }

        } else {

            try (InputStream in = PlatformClassPath.class

                    .getResourceAsStream("resources/jdeps-modules.xml")) {

                return new ArrayList<Archive>(ModulesXmlReader.load(mpath, in));

            }

        }

    }

    private static List<Archive> initLegacyImage(Path home) throws IOException {

        LegacyImageHelper cfr = new LegacyImageHelper(home);

        List<Archive> archives = new ArrayList<>(cfr.nonPlatformArchives);

        try (InputStream in = PlatformClassPath.class

                .getResourceAsStream("resources/jdeps-modules.xml")) {

            archives.addAll(ModulesXmlReader.loadFromImage(cfr, in));

            return archives;

        }

    }

    static class LegacyImageHelper {

        private static final List<String> NON_PLATFORM_JARFILES =

                Arrays.asList("alt-rt.jar", "jfxrt.jar", "ant-javafx.jar", "javafx-mx.jar");

        final List<Archive> nonPlatformArchives = new ArrayList<>();

        final List<JarFile> jarfiles = new ArrayList<>();

        final Path home;

        LegacyImageHelper(Path home) {

            this.home = home;

            try {

                if (home.endsWith("jre")) {

                    // jar files in <javahome>/jre/lib

                    addJarFiles(home.resolve("lib"));

                    if (home.getParent() != null) {

                        // add tools.jar and other JDK jar files

                        Path lib = home.getParent().resolve("lib");

                        if (Files.exists(lib)) {

                            addJarFiles(lib);

                        }

                    }

                } else if (Files.exists(home.resolve("lib"))) {

                    // add other JAR files

                    addJarFiles(home.resolve("lib"));

                } else {

                    throw new RuntimeException("\"" + home + "\" not a JDK home");

                }

            } catch (IOException e) {

                throw new Error(e);

            }

        }

        /**

         * Returns a ClassFileReader that only reads classes for the given modulename.

         */

        ClassFileReader getClassReader(String modulename, Set<String> packages) throws IOException {

            return new ModuleClassReader(modulename, packages);

        }

        private void addJarFiles(final Path root) throws IOException {

            final Path ext = root.resolve("ext");

            Files.walkFileTree(root, new SimpleFileVisitor<Path>() {

                @Override

                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)

                    throws IOException

                {

                    if (dir.equals(root) || dir.equals(ext)) {

                        return FileVisitResult.CONTINUE;

                    } else {

                        // skip other cobundled JAR files

                        return FileVisitResult.SKIP_SUBTREE;

                    }

                }

                @Override

                public FileVisitResult visitFile(Path p, BasicFileAttributes attrs)

                    throws IOException

                {

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

                    if (fn.endsWith(".jar")) {

                        // JDK may cobundle with JavaFX that doesn't belong to any profile

                        // Treat jfxrt.jar as regular Archive

                        if (NON_PLATFORM_JARFILES.contains(fn)) {

                            nonPlatformArchives.add(Archive.getInstance(p));

                        } else {

                            jarfiles.add(new JarFile(p.toFile()));

                        }

                    }

                    return FileVisitResult.CONTINUE;

                }

            });

        }

        /**

         * ModuleClassFile reads classes for the specified module from the legacy image.

         *

         */

        class ModuleClassReader extends JarFileReader {

            private JarFile cachedJarFile = getJarFile(0);

            private final Set<String> packages;

            private final String module;

            ModuleClassReader(String module, Set<String> packages) throws IOException {

                super(home, null);

                this.module = module;

                this.packages = packages;

            }

            private boolean includes(String name) {

                String cn = name.replace('/', '.');

                int i = cn.lastIndexOf('.');

                String pn = i > 0 ? cn.substring(0, i) : "";

                return packages.contains(pn);

            }

            private JarEntry findJarEntry(JarFile jarfile, String entryName1, String entryName2) {

                JarEntry e = jarfile.getJarEntry(entryName1);

                if (e == null) {

                    e = jarfile.getJarEntry(entryName2);

                }

                return e;

            }

            public String toString() {

                return module + " " + packages.size() + " " + packages;

            }

            @Override

            public ClassFile getClassFile(String name) throws IOException {

                if (jarfiles.isEmpty() || !includes(name)) {

                    return null;

                }

                if (name.indexOf('.') > 0) {

                    int i = name.lastIndexOf('.');

                    String entryName = name.replace('.', '/') + ".class";

                    String innerClassName = entryName.substring(0, i) + "$"

                            + entryName.substring(i + 1, entryName.length());

                    JarEntry e = findJarEntry(cachedJarFile, entryName, innerClassName);

                    if (e != null) {

                        return readClassFile(cachedJarFile, e);

                    }

                    for (JarFile jf : jarfiles) {

                        if (jf == cachedJarFile) {

                            continue;

                        }

                        System.err.format("find jar entry %s at %s%n", entryName, jf);

                        e = findJarEntry(jf, entryName, innerClassName);

                        if (e != null) {

                            cachedJarFile = jf;

                            return readClassFile(jf, e);

                        }

                    }

                } else {

                    String entryName = name + ".class";

                    JarEntry e = cachedJarFile.getJarEntry(entryName);

                    if (e != null) {

                        return readClassFile(cachedJarFile, e);

                    }

                    for (JarFile jf : jarfiles) {

                        if (jf == cachedJarFile) {

                            continue;

                        }

                        e = jf.getJarEntry(entryName);

                        if (e != null) {

                            cachedJarFile = jf;

                            return readClassFile(jf, e);

                        }

                    }

                }

                return null;

            }

            @Override

            public Iterable<ClassFile> getClassFiles() throws IOException {

                final Iterator<ClassFile> iter = new ModuleClassIterator(this);

                return new Iterable<ClassFile>() {

                    public Iterator<ClassFile> iterator() {

                        return iter;

                    }

                };

            }

            private JarFile getJarFile(int index) {

                return index < jarfiles.size() ? jarfiles.get(index) : null;

            }

            class ModuleClassIterator extends JarFileIterator {

                private int index;

                ModuleClassIterator(ModuleClassReader reader) {

                    super(reader);

                    this.index = 0;

                    this.jf = getJarFile(0);

                    this.entries = jf != null ? jf.entries() : null;

                    this.nextEntry = nextEntry();

                }

                @Override

                protected JarEntry nextEntry() {

                    while (jf != null) {

                        while (entries.hasMoreElements()) {

                            JarEntry e = entries.nextElement();

                            String name = e.getName();

                            if (name.endsWith(".class") && includes(name)) {

                                return e;

                            }

                        }

                        jf = getJarFile(++index);

                        entries = jf != null ? jf.entries() : null;

                    }

                    return null;

                }

            }

        }

    }

}