/*
 * Copyright (c) 2014, 2017, 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.jrtfs;

import java.io.ByteArrayInputStream;
import java.io.IOException;
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.FileSystemException;
import java.nio.file.InvalidPathException;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.NotDirectoryException;
import java.nio.file.OpenOption;
import java.nio.file.Path;
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.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.regex.Pattern;
import jdk.internal.jimage.ImageReader.Node;
import static java.util.stream.Collectors.toList;

jrt file system implementation built on System jimage files.
Implementation Note:
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./**
 * jrt file system implementation built on System jimage files.
 *
 * @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.
 */
class JrtFileSystem extends FileSystem {

    private final JrtFileSystemProvider provider;
    private final JrtPath rootPath = new JrtPath(this, "/");
    private volatile boolean isOpen;
    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;
    }

    // FileSystem method implementations
    @Override
    public boolean isOpen() {
        return isOpen;
    }

    @Override
    public void close() throws IOException {
        if (!isClosable)
            throw new UnsupportedOperationException();
        cleanup();
    }

    @Override
    @SuppressWarnings("deprecation")
    protected void finalize() throws Throwable {
        try {
            cleanup();
        } catch (IOException ignored) {}
    }

    @Override
    public FileSystemProvider provider() {
        return provider;
    }

    @Override
    public Iterable<Path> getRootDirectories() {
        return Collections.singleton(getRootPath());
    }

    @Override
    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();
    }

    @Override
    public final Iterable<FileStore> getFileStores() {
        return Collections.singleton(getFileStore(getRootPath()));
    }

    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 "/";
    }

    @Override
    public PathMatcher getPathMatcher(String syntaxAndInput) {
        int pos = syntaxAndInput.indexOf(':');
        if (pos <= 0 || pos == syntaxAndInput.length()) {
            throw new IllegalArgumentException("pos is " + pos);
        }
        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);
        if (node.isLink()) {
            node = node.resolveLink();
            return new JrtPath(this, node.getName());  // TBD, normalized?
        }
        return path;
    }

    JrtFileAttributes getFileAttributes(JrtPath path, LinkOption... options)
            throws IOException {
        Node node = checkNode(path);
        if (node.isLink() && followLinks(options)) {
            return new JrtFileAttributes(node.resolveLink(true));
        }
        return new JrtFileAttributes(node);
    }

    
returns the list of child paths of the given directory "path"
Params:
path – name of the directory whose content is listed
Returns:
iterator for child paths of the given directory 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(
                    "option class: " + option.getClass());
            }
        }
        if (options.contains(StandardOpenOption.WRITE) ||
            options.contains(StandardOpenOption.APPEND)) {
            throw readOnly();
        }
    }

    // clean up this file system - called from finalize and close
    synchronized void cleanup() throws IOException {
        if (isOpen) {
            isOpen = false;
            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 {
        try {
            checkNode(path);
        } catch (NoSuchFileException exp) {
            return false;
        }
        return true;
    }

    boolean isDirectory(JrtPath path, boolean resolveLinks)
            throws IOException {
        Node node = checkNode(path);
        return resolveLinks && node.isLink()
                ? node.resolveLink(true).isDirectory()
                : node.isDirectory();
    }

    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 | IOException ex) {
            throw new InvalidPathException(path, ex.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++;
        }
        return null;
    }

    Node checkNode(JrtPath path) throws IOException {
        ensureOpen();
        String p = path.getResolvedPath();
        Node node = lookup(p);
        if (node == null) {
            node = lookupSymbolic(p);
            if (node == null) {
                throw new NoSuchFileException(p);
            }
        }
        return node;
    }
}