/*

 * Copyright (c) 2014, 2016, 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.jimage;

import java.io.IOException;

import java.io.InputStream;

import java.io.UncheckedIOException;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.IntBuffer;

import java.nio.file.Files;

import java.nio.file.attribute.BasicFileAttributes;

import java.nio.file.attribute.FileTime;

import java.nio.file.Path;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.function.Consumer;

/**

 * @implNote This class needs to maintain JDK 8 source compatibility.

 *

 * It is used internally in the JDK to implement jimage/jrtfs access,

 * but also compiled and delivered as part of the jrtfs.jar to support access

 * to the jimage file provided by the shipped JDK by tools running on JDK 8.

 */

public final class ImageReader implements AutoCloseable {

    private final SharedImageReader reader;

    private volatile boolean closed;

    private ImageReader(SharedImageReader reader) {

        this.reader = reader;

    }

    public static ImageReader open(Path imagePath, ByteOrder byteOrder) throws IOException {

        Objects.requireNonNull(imagePath);

        Objects.requireNonNull(byteOrder);

        return SharedImageReader.open(imagePath, byteOrder);

    }

    public static ImageReader open(Path imagePath) throws IOException {

        return open(imagePath, ByteOrder.nativeOrder());

    }

    @Override

    public void close() throws IOException {

        if (closed) {

            throw new IOException("image file already closed");

        }

        reader.close(this);

        closed = true;

    }

    private void ensureOpen() throws IOException {

        if (closed) {

            throw new IOException("image file closed");

        }

    }

    private void requireOpen() {

        if (closed) {

            throw new IllegalStateException("image file closed");

        }

    }

    // directory management interface

    public Directory getRootDirectory() throws IOException {

        ensureOpen();

        return reader.getRootDirectory();

    }

    public Node findNode(String name) throws IOException {

        ensureOpen();

        return reader.findNode(name);

    }

    public byte[] getResource(Node node) throws IOException {

        ensureOpen();

        return reader.getResource(node);

    }

    public byte[] getResource(Resource rs) throws IOException {

        ensureOpen();

        return reader.getResource(rs);

    }

    public ImageHeader getHeader() {

        requireOpen();

        return reader.getHeader();

    }

    public static void releaseByteBuffer(ByteBuffer buffer) {

        BasicImageReader.releaseByteBuffer(buffer);

    }

    public String getName() {

        requireOpen();

        return reader.getName();

    }

    public ByteOrder getByteOrder() {

        requireOpen();

        return reader.getByteOrder();

    }

    public Path getImagePath() {

        requireOpen();

        return reader.getImagePath();

    }

    public ImageStringsReader getStrings() {

        requireOpen();

        return reader.getStrings();

    }

    public ImageLocation findLocation(String mn, String rn) {

        requireOpen();

        return reader.findLocation(mn, rn);

    }

    public ImageLocation findLocation(String name) {

        requireOpen();

        return reader.findLocation(name);

    }

    public String[] getEntryNames() {

        requireOpen();

        return reader.getEntryNames();

    }

    public String[] getModuleNames() {

        requireOpen();

        int off = "/modules/".length();

        return reader.findNode("/modules")

                     .getChildren()

                     .stream()

                     .map(Node::getNameString)

                     .map(s -> s.substring(off, s.length()))

                     .toArray(String[]::new);

    }

    public long[] getAttributes(int offset) {

        requireOpen();

        return reader.getAttributes(offset);

    }

    public String getString(int offset) {

        requireOpen();

        return reader.getString(offset);

    }

    public byte[] getResource(String name) {

        requireOpen();

        return reader.getResource(name);

    }

    public byte[] getResource(ImageLocation loc) {

        requireOpen();

        return reader.getResource(loc);

    }

    public ByteBuffer getResourceBuffer(ImageLocation loc) {

        requireOpen();

        return reader.getResourceBuffer(loc);

    }

    public InputStream getResourceStream(ImageLocation loc) {

        requireOpen();

        return reader.getResourceStream(loc);

    }

    private final static class SharedImageReader extends BasicImageReader {

        static final int SIZE_OF_OFFSET = Integer.BYTES;

        static final Map<Path, SharedImageReader> OPEN_FILES = new HashMap<>();

        // List of openers for this shared image.

        final Set<ImageReader> openers;

        // attributes of the .jimage file. jimage file does not contain

        // attributes for the individual resources (yet). We use attributes

        // of the jimage file itself (creation, modification, access times).

        // Iniitalized lazily, see {@link #imageFileAttributes()}.

        BasicFileAttributes imageFileAttributes;

        // directory management implementation

        final HashMap<String, Node> nodes;

        volatile Directory rootDir;

        Directory packagesDir;

        Directory modulesDir;

        private SharedImageReader(Path imagePath, ByteOrder byteOrder) throws IOException {

            super(imagePath, byteOrder);

            this.openers = new HashSet<>();

            this.nodes = new HashMap<>();

        }

        public static ImageReader open(Path imagePath, ByteOrder byteOrder) throws IOException {

            Objects.requireNonNull(imagePath);

            Objects.requireNonNull(byteOrder);

            synchronized (OPEN_FILES) {

                SharedImageReader reader = OPEN_FILES.get(imagePath);

                if (reader == null) {

                    // Will fail with an IOException if wrong byteOrder.

                    reader =  new SharedImageReader(imagePath, byteOrder);

                    OPEN_FILES.put(imagePath, reader);

                } else if (reader.getByteOrder() != byteOrder) {

                    throw new IOException("\"" + reader.getName() + "\" is not an image file");

                }

                ImageReader image = new ImageReader(reader);

                reader.openers.add(image);

                return image;

            }

        }

        public void close(ImageReader image) throws IOException {

            Objects.requireNonNull(image);

            synchronized (OPEN_FILES) {

                if (!openers.remove(image)) {

                    throw new IOException("image file already closed");

                }

                if (openers.isEmpty()) {

                    close();

                    nodes.clear();

                    rootDir = null;

                    if (!OPEN_FILES.remove(this.getImagePath(), this)) {

                        throw new IOException("image file not found in open list");

                    }

                }

            }

        }

        void addOpener(ImageReader reader) {

            synchronized (OPEN_FILES) {

                openers.add(reader);

            }

        }

        boolean removeOpener(ImageReader reader) {

            synchronized (OPEN_FILES) {

                return openers.remove(reader);

            }

        }

        // directory management interface

        Directory getRootDirectory() {

            return buildRootDirectory();

        }

        /**

         * Lazily build a node from a name.

        */

        synchronized Node buildNode(String name) {

            Node n;

            boolean isPackages = name.startsWith("/packages");

            boolean isModules = !isPackages && name.startsWith("/modules");

            if (!(isModules || isPackages)) {

                return null;

            }

            ImageLocation loc = findLocation(name);

            if (loc != null) { // A sub tree node

                if (isPackages) {

                    n = handlePackages(name, loc);

                } else { // modules sub tree

                    n = handleModulesSubTree(name, loc);

                }

            } else { // Asking for a resource? /modules/java.base/java/lang/Object.class

                if (isModules) {

                    n = handleResource(name);

                } else {

                    // Possibly ask for /packages/java.lang/java.base

                    // although /packages/java.base not created

                    n = handleModuleLink(name);

                }

            }

            return n;

        }

        synchronized Directory buildRootDirectory() {

            Directory root = rootDir; // volatile read

            if (root != null) {

                return root;

            }

            root = newDirectory(null, "/");

            root.setIsRootDir();

            // /packages dir

            packagesDir = newDirectory(root, "/packages");

            packagesDir.setIsPackagesDir();

            // /modules dir

            modulesDir = newDirectory(root, "/modules");

            modulesDir.setIsModulesDir();

            root.setCompleted(true);

            return rootDir = root;

        }

        /**

         * To visit sub tree resources.

         */

        interface LocationVisitor {

            void visit(ImageLocation loc);

        }

        void visitLocation(ImageLocation loc, LocationVisitor visitor) {

            byte[] offsets = getResource(loc);

            ByteBuffer buffer = ByteBuffer.wrap(offsets);

            buffer.order(getByteOrder());

            IntBuffer intBuffer = buffer.asIntBuffer();

            for (int i = 0; i < offsets.length / SIZE_OF_OFFSET; i++) {

                int offset = intBuffer.get(i);

                ImageLocation pkgLoc = getLocation(offset);

                visitor.visit(pkgLoc);

            }

        }

        void visitPackageLocation(ImageLocation loc) {

            // Retrieve package name

            String pkgName = getBaseExt(loc);

            // Content is array of offsets in Strings table

            byte[] stringsOffsets = getResource(loc);

            ByteBuffer buffer = ByteBuffer.wrap(stringsOffsets);

            buffer.order(getByteOrder());

            IntBuffer intBuffer = buffer.asIntBuffer();

            // For each module, create a link node.

            for (int i = 0; i < stringsOffsets.length / SIZE_OF_OFFSET; i++) {

                // skip empty state, useless.

                intBuffer.get(i);

                i++;

                int offset = intBuffer.get(i);

                String moduleName = getString(offset);

                Node targetNode = findNode("/modules/" + moduleName);

                if (targetNode != null) {

                    String pkgDirName = packagesDir.getName() + "/" + pkgName;

                    Directory pkgDir = (Directory) nodes.get(pkgDirName);

                    newLinkNode(pkgDir, pkgDir.getName() + "/" + moduleName, targetNode);

                }

            }

        }

        Node handlePackages(String name, ImageLocation loc) {

            long size = loc.getUncompressedSize();

            Node n = null;

            // Only possiblities are /packages, /packages/package/module

            if (name.equals("/packages")) {

                visitLocation(loc, (childloc) -> {

                    findNode(childloc.getFullName());

                });

                packagesDir.setCompleted(true);

                n = packagesDir;

            } else {

                if (size != 0) { // children are offsets to module in StringsTable

                    String pkgName = getBaseExt(loc);

                    Directory pkgDir = newDirectory(packagesDir, packagesDir.getName() + "/" + pkgName);

                    visitPackageLocation(loc);

                    pkgDir.setCompleted(true);

                    n = pkgDir;

                } else { // Link to module

                    String pkgName = loc.getParent();

                    String modName = getBaseExt(loc);

                    Node targetNode = findNode("/modules/" + modName);

                    if (targetNode != null) {

                        String pkgDirName = packagesDir.getName() + "/" + pkgName;

                        Directory pkgDir = (Directory) nodes.get(pkgDirName);

                        Node linkNode = newLinkNode(pkgDir, pkgDir.getName() + "/" + modName, targetNode);

                        n = linkNode;

                    }

                }

            }

            return n;

        }

        // Asking for /packages/package/module although

        // /packages/<pkg>/ not yet created, need to create it

        // prior to return the link to module node.

        Node handleModuleLink(String name) {

            // eg: unresolved /packages/package/module

            // Build /packages/package node

            Node ret = null;

            String radical = "/packages/";

            String path = name;

            if (path.startsWith(radical)) {

                int start = radical.length();

                int pkgEnd = path.indexOf('/', start);

                if (pkgEnd != -1) {

                    String pkg = path.substring(start, pkgEnd);

                    String pkgPath = radical + pkg;

                    Node n = findNode(pkgPath);

                    // If not found means that this is a symbolic link such as:

                    // /packages/java.util/java.base/java/util/Vector.class

                    // and will be done by a retry of the filesystem

                    for (Node child : n.getChildren()) {

                        if (child.name.equals(name)) {

                            ret = child;

                            break;

                        }

                    }

                }

            }

            return ret;

        }

        Node handleModulesSubTree(String name, ImageLocation loc) {

            Node n;

            assert (name.equals(loc.getFullName()));

            Directory dir = makeDirectories(name);

            visitLocation(loc, (childloc) -> {

                String path = childloc.getFullName();

                if (path.startsWith("/modules")) { // a package

                    makeDirectories(path);

                } else { // a resource

                    makeDirectories(childloc.buildName(true, true, false));

                    newResource(dir, childloc);

                }

            });

            dir.setCompleted(true);

            n = dir;

            return n;

        }

        Node handleResource(String name) {

            Node n = null;

            String locationPath = name.substring("/modules".length());

            ImageLocation resourceLoc = findLocation(locationPath);

            if (resourceLoc != null) {

                Directory dir = makeDirectories(resourceLoc.buildName(true, true, false));

                Resource res = newResource(dir, resourceLoc);

                n = res;

            }

            return n;

        }

        String getBaseExt(ImageLocation loc) {

            String base = loc.getBase();

            String ext = loc.getExtension();

            if (ext != null && !ext.isEmpty()) {

                base = base + "." + ext;

            }

            return base;

        }

        synchronized Node findNode(String name) {

            buildRootDirectory();

            Node n = nodes.get(name);

            if (n == null || !n.isCompleted()) {

                n = buildNode(name);

            }

            return n;

        }

        /**