import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.nio.ByteBuffer;

import java.nio.channels.Channels;

import java.nio.channels.FileChannel;

import java.nio.channels.NonWritableChannelException;

import java.nio.channels.ReadableByteChannel;

import java.nio.channels.SeekableByteChannel;

import java.nio.file.ClosedFileSystemException;

import java.nio.file.CopyOption;

import java.nio.file.DirectoryStream;

import java.nio.file.FileStore;

import java.nio.file.FileSystem;

import java.nio.file.LinkOption;

import java.nio.file.OpenOption;

import java.nio.file.PathMatcher;

import java.nio.file.ReadOnlyFileSystemException;

import java.nio.file.StandardOpenOption;

import java.nio.file.WatchService;

import java.nio.file.attribute.FileAttribute;

import java.nio.file.attribute.FileTime;

import java.nio.file.attribute.UserPrincipalLookupService;

import java.nio.file.spi.FileSystemProvider;

import java.util.Collections;

import java.util.HashSet;

import java.util.Objects;

import java.util.Set;

import java.util.regex.Pattern;

import jdk.internal.jimage.ImageReader.Node;

class JrtFileSystem extends FileSystem {

    private final JrtFileSystemProvider provider;

    private final JrtPath rootPath = new JrtPath(this, "/");

    private volatile boolean isClosable;

    private SystemImage image;

    JrtFileSystem(JrtFileSystemProvider provider, Map<String, ?> env)

            throws IOException

    {

        this.provider = provider;

        this.image = SystemImage.open();  // open image file

        this.isOpen = true;

        this.isClosable = env != null;

        if (!isClosable)

            throw new UnsupportedOperationException();

        } catch (IOException ignored) {}

    public FileSystemProvider provider() {

        return provider;

    }

    @Override

    public Iterable<Path> getRootDirectories() {

        ArrayList<Path> dirs = new ArrayList<>();

        dirs.add(getRootPath());

        return dirs;

    public JrtPath getPath(String first, String... more) {

        if (more.length == 0) {

            return new JrtPath(this, first);

        }

        StringBuilder sb = new StringBuilder();

        sb.append(first);

        for (String path : more) {

            if (path.length() > 0) {

                if (sb.length() > 0) {

                    sb.append('/');

                }

                sb.append(path);

            }

        }

        return new JrtPath(this, sb.toString());

    }

    @Override

    public final boolean isReadOnly() {

        return true;

    }

    @Override

    public final UserPrincipalLookupService getUserPrincipalLookupService() {

        throw new UnsupportedOperationException();

    }

    @Override

    public final WatchService newWatchService() {

        throw new UnsupportedOperationException();

    public final Iterable<FileStore> getFileStores() {

        ArrayList<FileStore> list = new ArrayList<>(1);

        list.add(getFileStore(getRootPath()));

        return list;

    }

    private static final Set<String> supportedFileAttributeViews

            = Collections.unmodifiableSet(

                    new HashSet<String>(Arrays.asList("basic", "jrt")));

    @Override

    public final Set<String> supportedFileAttributeViews() {

        return supportedFileAttributeViews;

    }

    @Override

    public final String toString() {

        return "jrt:/";

    }

    @Override

    public final String getSeparator() {

        return "/";

    public PathMatcher getPathMatcher(String syntaxAndInput) {

        int pos = syntaxAndInput.indexOf(':');

        if (pos <= 0 || pos == syntaxAndInput.length()) {

            throw new IllegalArgumentException();

        }

        String syntax = syntaxAndInput.substring(0, pos);

        String input = syntaxAndInput.substring(pos + 1);

        String expr;

        if (syntax.equalsIgnoreCase("glob")) {

            expr = JrtUtils.toRegexPattern(input);

        } else if (syntax.equalsIgnoreCase("regex")) {

            expr = input;

        } else {

                throw new UnsupportedOperationException("Syntax '" + syntax

                        + "' not recognized");

        }

        // return matcher

        final Pattern pattern = Pattern.compile(expr);

        return (Path path) -> pattern.matcher(path.toString()).matches();

    }

    JrtPath resolveLink(JrtPath path) throws IOException {

        Node node = checkNode(path);

            return new JrtPath(this, node.getName());  // TBD, normalized?

        return path;

    JrtFileAttributes getFileAttributes(JrtPath path, LinkOption... options)

        Node node = checkNode(path);

    /**

     * returns the list of child paths of the given directory "path"

     *

     * @param path name of the directory whose content is listed

     * @return iterator for child paths of the given directory path

     */

    Iterator<Path> iteratorOf(JrtPath path, DirectoryStream.Filter<? super Path> filter)

            throws IOException {

        Node node = checkNode(path).resolveLink(true);

        if (!node.isDirectory()) {

            throw new NotDirectoryException(path.getName());

        }

        if (filter == null) {

            return node.getChildren()

                       .stream()

                       .map(child -> (Path)(path.resolve(new JrtPath(this, child.getNameString()).getFileName())))

                       .iterator();

        }

        return node.getChildren()

                   .stream()

                   .map(child -> (Path)(path.resolve(new JrtPath(this, child.getNameString()).getFileName())))

                   .filter(p ->  { try { return filter.accept(p);

                                   } catch (IOException x) {}

                                   return false;

                                  })

                   .iterator();

    }

    // returns the content of the file resource specified by the path

    byte[] getFileContent(JrtPath path) throws IOException {

        Node node = checkNode(path);

        if (node.isDirectory()) {

            throw new FileSystemException(path + " is a directory");

        }

        //assert node.isResource() : "resource node expected here";

        return image.getResource(node);

    }

    /////////////// Implementation details below this point //////////

    // static utility methods

    static ReadOnlyFileSystemException readOnly() {

        return new ReadOnlyFileSystemException();

    }

    // do the supplied options imply that we have to chase symlinks?

    static boolean followLinks(LinkOption... options) {

        if (options != null) {

            for (LinkOption lo : options) {

                Objects.requireNonNull(lo);

                if (lo == LinkOption.NOFOLLOW_LINKS) {

                    return false;

                } else {

                    throw new AssertionError("should not reach here");

                }

            }

        }

        return true;

    }

    // check that the options passed are supported by (read-only) jrt file system

    static void checkOptions(Set<? extends OpenOption> options) {

        // check for options of null type and option is an intance of StandardOpenOption

        for (OpenOption option : options) {

            Objects.requireNonNull(option);

            if (!(option instanceof StandardOpenOption)) {

                throw new IllegalArgumentException();

            }

        }

        if (options.contains(StandardOpenOption.WRITE) ||

            options.contains(StandardOpenOption.APPEND)) {

            throw readOnly();

        }

    }

    // clean up this file system - called from finalize and close

    void cleanup() throws IOException {

        if (!isOpen) {

            return;

        }

        synchronized (this) {

            isOpen = false;

            // close image reader and null out

            image.close();

            image = null;

        }

    }

    // These methods throw read only file system exception

    final void setTimes(JrtPath jrtPath, FileTime mtime, FileTime atime, FileTime ctime)

            throws IOException {

        throw readOnly();

    }

    // These methods throw read only file system exception

    final void createDirectory(JrtPath jrtPath, FileAttribute<?>... attrs) throws IOException {

        throw readOnly();

    }

    final void deleteFile(JrtPath jrtPath, boolean failIfNotExists)

            throws IOException {

        throw readOnly();

    }

    final OutputStream newOutputStream(JrtPath jrtPath, OpenOption... options)

            throws IOException {

        throw readOnly();

    }

    final void copyFile(boolean deletesrc, JrtPath srcPath, JrtPath dstPath, CopyOption... options)

            throws IOException {

        throw readOnly();

    }

    final FileChannel newFileChannel(JrtPath path,

            Set<? extends OpenOption> options,

            FileAttribute<?>... attrs)

            throws IOException {

        throw new UnsupportedOperationException("newFileChannel");

    }

    final InputStream newInputStream(JrtPath path) throws IOException {

        return new ByteArrayInputStream(getFileContent(path));

    }

    final SeekableByteChannel newByteChannel(JrtPath path,

            Set<? extends OpenOption> options,

            FileAttribute<?>... attrs)

            throws IOException {

        checkOptions(options);

        byte[] buf = getFileContent(path);

        final ReadableByteChannel rbc

                = Channels.newChannel(new ByteArrayInputStream(buf));

        final long size = buf.length;

        return new SeekableByteChannel() {

            long read = 0;

            @Override

            public boolean isOpen() {

                return rbc.isOpen();

            }

            @Override

            public long position() throws IOException {

                return read;

            }

            @Override

            public SeekableByteChannel position(long pos)

                    throws IOException {

                throw new UnsupportedOperationException();

            }

            @Override

            public int read(ByteBuffer dst) throws IOException {

                int n = rbc.read(dst);

                if (n > 0) {

                    read += n;

                }

                return n;

            }

            @Override

            public SeekableByteChannel truncate(long size)

                    throws IOException {

                throw new NonWritableChannelException();

            }

            @Override

            public int write(ByteBuffer src) throws IOException {

                throw new NonWritableChannelException();

            }

            @Override

            public long size() throws IOException {

                return size;

            }

            @Override

            public void close() throws IOException {

                rbc.close();

            }

        };

    }

    final JrtFileStore getFileStore(JrtPath path) {

        return new JrtFileStore(path);

    }

    final void ensureOpen() throws IOException {

        if (!isOpen()) {

            throw new ClosedFileSystemException();

        }

    }

    final JrtPath getRootPath() {

        return rootPath;

    }

    boolean isSameFile(JrtPath path1, JrtPath path2) throws IOException {

        return checkNode(path1) == checkNode(path2);

    }

    boolean isLink(JrtPath path) throws IOException {

        return checkNode(path).isLink();

    }

    boolean exists(JrtPath path) throws IOException {

            checkNode(path);

    boolean isDirectory(JrtPath path, boolean resolveLinks)

        Node node = checkNode(path);

    JrtPath toRealPath(JrtPath path, LinkOption... options)

            throws IOException {

        Node node = checkNode(path);

        if (followLinks(options) && node.isLink()) {

            node = node.resolveLink();

        // image node holds the real/absolute path name

        return new JrtPath(this, node.getName(), true);

    private Node lookup(String path) {

        try {

            return image.findNode(path);

        } catch (RuntimeException re) {

            throw new InvalidPathException(path, re.toString());

    private Node lookupSymbolic(String path) {

        int i = 1;

        while (i < path.length()) {

            i = path.indexOf('/', i);

            if (i == -1) {

                break;

            }

            String prefix = path.substring(0, i);

            Node node = lookup(prefix);

            if (node == null) {

                break;

            }

            if (node.isLink()) {

                Node link = node.resolveLink(true);

                // resolved symbolic path concatenated to the rest of the path

                String resPath = link.getName() + path.substring(i);

                node = lookup(resPath);

                return node != null ? node : lookupSymbolic(resPath);

            }

            i++;

    Node checkNode(JrtPath path) throws IOException {

        ensureOpen();

        String p = path.getResolvedPath();