/*

 * 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.nio.file.*;

import java.nio.file.attribute.*;

import java.nio.file.spi.FileSystemProvider;

import java.nio.channels.SeekableByteChannel;

import java.net.URI;

import java.util.*;

import java.io.*;

/**

 * A "pass through" file system implementation that passes through, or delegates,

 * everything to the default file system.

 */

class PassThroughFileSystem extends FileSystem {

    private final FileSystemProvider provider;

    private final FileSystem delegate;

    PassThroughFileSystem(FileSystemProvider provider, FileSystem delegate) {

        this.provider = provider;

        this.delegate = delegate;

    }

    /**

     * Creates a new "pass through" file system. Useful for test environments

     * where the provider might not be deployed.

     */

    static FileSystem create() throws IOException {

        FileSystemProvider provider = new PassThroughProvider();

        Map<String,?> env = Collections.emptyMap();

        URI uri = URI.create("pass:///");

        return provider.newFileSystem(uri, env);

    }

    static Path unwrap(Path wrapper) {

        if (wrapper == null)

            throw new NullPointerException();

        if (!(wrapper instanceof PassThroughPath))

            throw new ProviderMismatchException();

        return ((PassThroughPath)wrapper).delegate;

    }

    @Override

    public FileSystemProvider provider() {

        return provider;

    }

    @Override

    public void close() throws IOException {

        delegate.close();

    }

    @Override

    public boolean isOpen() {

        return delegate.isOpen();

    }

    @Override

    public boolean isReadOnly() {

        return delegate.isReadOnly();

    }

    @Override

    public String getSeparator() {

        return delegate.getSeparator();

    }

    @Override

    public Iterable<Path> getRootDirectories() {

        final Iterable<Path> roots = delegate.getRootDirectories();

        return new Iterable<Path>() {

            @Override

            public Iterator<Path> iterator() {

                final Iterator<Path> itr = roots.iterator();

                return new Iterator<Path>() {

                    @Override

                    public boolean hasNext() {

                        return itr.hasNext();

                    }

                    @Override

                    public Path next() {

                        return new PassThroughPath(delegate, itr.next());

                    }

                    @Override

                    public void remove() {

                        itr.remove();

                    }

                };

            }

        };

    }

    @Override

    public Iterable<FileStore> getFileStores() {

        // assume that unwrapped objects aren't exposed

        return delegate.getFileStores();

    }

    @Override

    public Set<String> supportedFileAttributeViews() {

        // assume that unwrapped objects aren't exposed

        return delegate.supportedFileAttributeViews();

    }

    @Override

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

        return new PassThroughPath(this, delegate.getPath(first, more));

    }

    @Override

    public PathMatcher getPathMatcher(String syntaxAndPattern) {

        final PathMatcher matcher = delegate.getPathMatcher(syntaxAndPattern);

        return new PathMatcher() {

            @Override

            public boolean matches(Path path) {

                return matcher.matches(unwrap(path));

            }

        };

    }

    @Override

    public UserPrincipalLookupService getUserPrincipalLookupService() {

        // assume that unwrapped objects aren't exposed

        return delegate.getUserPrincipalLookupService();

    }

    @Override

    public WatchService newWatchService() throws IOException {

        // to keep it simple

        throw new UnsupportedOperationException();

    }

    static class PassThroughProvider extends FileSystemProvider {

        private static final String SCHEME = "pass";

        private static volatile PassThroughFileSystem delegate;

        public PassThroughProvider() { }

        @Override

        public String getScheme() {

            return SCHEME;

        }

        private void checkScheme(URI uri) {

            if (!uri.getScheme().equalsIgnoreCase(SCHEME))

                throw new IllegalArgumentException();

        }

        private void checkUri(URI uri) {

            checkScheme(uri);

            if (!uri.getSchemeSpecificPart().equals("///"))

                throw new IllegalArgumentException();

        }

        @Override

        public FileSystem newFileSystem(URI uri, Map<String,?> env)

            throws IOException

        {

            checkUri(uri);

            synchronized (PassThroughProvider.class) {

                if (delegate != null)

                    throw new FileSystemAlreadyExistsException();

                PassThroughFileSystem result =

                    new PassThroughFileSystem(this, FileSystems.getDefault());

                delegate = result;

                return result;

            }

        }

        @Override

        public FileSystem getFileSystem(URI uri) {

            checkUri(uri);

            FileSystem result = delegate;

            if (result == null)

                throw new FileSystemNotFoundException();

            return result;

        }

        @Override

        public Path getPath(URI uri) {

            checkScheme(uri);

            if (delegate == null)

                throw new FileSystemNotFoundException();

            uri = URI.create(delegate.provider().getScheme() + ":" +

                             uri.getSchemeSpecificPart());

            return new PassThroughPath(delegate, delegate.provider().getPath(uri));

        }

        @Override

        public void setAttribute(Path file, String attribute, Object value, LinkOption... options)

            throws IOException

        {

            Files.setAttribute(unwrap(file), attribute, value, options);

        }

        @Override

        public Map<String,Object> readAttributes(Path file, String attributes, LinkOption... options)

            throws IOException

        {

            return Files.readAttributes(unwrap(file), attributes, options);

        }

        @Override

        public <V extends FileAttributeView> V getFileAttributeView(Path file,

                                                                    Class<V> type,

                                                                    LinkOption... options)

        {

            return Files.getFileAttributeView(unwrap(file), type, options);

        }

        @Override

        public <A extends BasicFileAttributes> A readAttributes(Path file,

                                                                Class<A> type,

                                                                LinkOption... options)

            throws IOException

        {

            return Files.readAttributes(unwrap(file), type, options);

        }

        @Override

        public void delete(Path file) throws IOException {

            Files.delete(unwrap(file));

        }

        @Override

        public void createSymbolicLink(Path link, Path target, FileAttribute<?>... attrs)

            throws IOException

        {

            Files.createSymbolicLink(unwrap(link), unwrap(target), attrs);

        }

        @Override

        public void createLink(Path link, Path existing) throws IOException {

            Files.createLink(unwrap(link), unwrap(existing));

        }

        @Override

        public Path readSymbolicLink(Path link) throws IOException {

            Path target = Files.readSymbolicLink(unwrap(link));

            return new PassThroughPath(delegate, target);

        }

        @Override

        public void copy(Path source, Path target, CopyOption... options) throws IOException {

            Files.copy(unwrap(source), unwrap(target), options);

        }

        @Override

        public void move(Path source, Path target, CopyOption... options) throws IOException {

            Files.move(unwrap(source), unwrap(target), options);

        }

        private DirectoryStream<Path> wrap(final DirectoryStream<Path> stream) {

            return new DirectoryStream<Path>() {

                @Override

                public Iterator<Path> iterator() {

                    final Iterator<Path> itr = stream.iterator();

                    return new Iterator<Path>() {

                        @Override

                        public boolean hasNext() {

                            return itr.hasNext();

                        }

                        @Override

                        public Path next() {

                            return new PassThroughPath(delegate, itr.next());

                        }

                        @Override

                        public void remove() {

                            itr.remove();

                        }

                    };

                }

                @Override

                public void close() throws IOException {

                    stream.close();

                }

            };

        }

        @Override

        public DirectoryStream<Path> newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter)

            throws IOException

        {

            return wrap(Files.newDirectoryStream(dir, filter));

        }

        @Override

        public void createDirectory(Path dir, FileAttribute<?>... attrs)

            throws IOException

        {

            Files.createDirectory(unwrap(dir), attrs);

        }

        @Override

        public SeekableByteChannel newByteChannel(Path file,

                                                  Set<? extends OpenOption> options,

                                                  FileAttribute<?>... attrs)

            throws IOException

        {

            return Files.newByteChannel(unwrap(file), options, attrs);

        }

        @Override

        public boolean isHidden(Path file) throws IOException {

            return Files.isHidden(unwrap(file));

        }

        @Override

        public FileStore getFileStore(Path file) throws IOException {

            return Files.getFileStore(unwrap(file));

        }

        @Override

        public boolean isSameFile(Path file, Path other) throws IOException {

            return Files.isSameFile(unwrap(file), unwrap(other));

        }

        @Override

        public void checkAccess(Path file, AccessMode... modes)

            throws IOException

        {

            // hack

            if (modes.length == 0) {

                if (Files.exists(unwrap(file)))

                    return;

                else

                    throw new NoSuchFileException(file.toString());

            }

            throw new RuntimeException("not implemented yet");

        }

    }

    static class PassThroughPath implements Path {

        private final FileSystem fs;

        private final Path delegate;

        PassThroughPath(FileSystem fs, Path delegate) {

            this.fs = fs;

            this.delegate = delegate;

        }

        private Path wrap(Path path) {

            return (path != null) ? new PassThroughPath(fs, path) : null;

        }

        @Override

        public FileSystem getFileSystem() {

            return fs;

        }

        @Override

        public boolean isAbsolute() {

            return delegate.isAbsolute();

        }

        @Override

        public Path getRoot() {

            return wrap(delegate.getRoot());

        }

        @Override

        public Path getParent() {

            return wrap(delegate.getParent());

        }

        @Override

        public int getNameCount() {

            return delegate.getNameCount();

        }

        @Override

        public Path getFileName() {

            return wrap(delegate.getFileName());

        }

        @Override

        public Path getName(int index) {

            return wrap(delegate.getName(index));

        }

        @Override

        public Path subpath(int beginIndex, int endIndex) {

            return wrap(delegate.subpath(beginIndex, endIndex));

        }

        @Override

        public boolean startsWith(Path other) {

            return delegate.startsWith(unwrap(other));

        }

        @Override

        public boolean startsWith(String other) {

            return delegate.startsWith(other);

        }

        @Override

        public boolean endsWith(Path other) {

            return delegate.endsWith(unwrap(other));

        }

        @Override

        public boolean endsWith(String other) {

            return delegate.endsWith(other);

        }

        @Override

        public Path normalize() {

            return wrap(delegate.normalize());

        }

        @Override

        public Path resolve(Path other) {

            return wrap(delegate.resolve(unwrap(other)));

        }

        @Override

        public Path resolve(String other) {

            return wrap(delegate.resolve(other));

        }

        @Override

        public Path resolveSibling(Path other) {

            return wrap(delegate.resolveSibling(unwrap(other)));

        }

        @Override

        public Path resolveSibling(String other) {

            return wrap(delegate.resolveSibling(other));

        }

        @Override

        public Path relativize(Path other) {

            return wrap(delegate.relativize(unwrap(other)));

        }

        @Override

        public boolean equals(Object other) {

            if (!(other instanceof PassThroughPath))

                return false;

            return delegate.equals(unwrap((PassThroughPath)other));

        }

        @Override

        public int hashCode() {

            return delegate.hashCode();

        }

        @Override

        public String toString() {

            return delegate.toString();

        }

        @Override

        public URI toUri() {

            String ssp = delegate.toUri().getSchemeSpecificPart();

            return URI.create(fs.provider().getScheme() + ":" + ssp);

        }

        @Override

        public Path toAbsolutePath() {

            return wrap(delegate.toAbsolutePath());

        }

        @Override

        public Path toRealPath(boolean resolveLinks) throws IOException {

            return wrap(delegate.toRealPath(resolveLinks));

        }

        @Override

        public File toFile() {

            return delegate.toFile();

        }

        @Override

        public Iterator<Path> iterator() {

            final Iterator<Path> itr = delegate.iterator();

            return new Iterator<Path>() {

                @Override

                public boolean hasNext() {

                    return itr.hasNext();

                }

                @Override

                public Path next() {

                    return wrap(itr.next());

                }

                @Override

                public void remove() {

                    itr.remove();

                }