/*

 * Copyright (c) 2009, 2019, 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.nio.zipfs;

import java.io.BufferedOutputStream;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.EOFException;

import java.io.FilterOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.nio.ByteBuffer;

import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.nio.channels.FileLock;

import java.nio.channels.ReadableByteChannel;

import java.nio.channels.SeekableByteChannel;

import java.nio.channels.WritableByteChannel;

import java.nio.file.*;

import java.nio.file.attribute.*;

import java.nio.file.spi.FileSystemProvider;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

import java.util.*;

import java.util.concurrent.locks.ReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import java.util.regex.Pattern;

import java.util.zip.CRC32;

import java.util.zip.Deflater;

import java.util.zip.DeflaterOutputStream;

import java.util.zip.Inflater;

import java.util.zip.InflaterInputStream;

import java.util.zip.ZipException;

import static java.lang.Boolean.TRUE;

import static java.nio.file.StandardCopyOption.COPY_ATTRIBUTES;

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;

import static java.nio.file.StandardOpenOption.APPEND;

import static java.nio.file.StandardOpenOption.CREATE;

import static java.nio.file.StandardOpenOption.CREATE_NEW;

import static java.nio.file.StandardOpenOption.READ;

import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING;

import static java.nio.file.StandardOpenOption.WRITE;

import static jdk.nio.zipfs.ZipConstants.*;

import static jdk.nio.zipfs.ZipUtils.*;

/**

 * A FileSystem built on a zip file

 *

 * @author Xueming Shen

 */

class ZipFileSystem extends FileSystem {

    // statics

    private static final boolean isWindows = AccessController.doPrivileged(

        (PrivilegedAction<Boolean>)()->System.getProperty("os.name")

                                             .startsWith("Windows"));

    private static final byte[] ROOTPATH = new byte[] { '/' };

    private static final String PROPERTY_POSIX = "enablePosixFileAttributes";

    private static final String PROPERTY_DEFAULT_OWNER = "defaultOwner";

    private static final String PROPERTY_DEFAULT_GROUP = "defaultGroup";

    private static final String PROPERTY_DEFAULT_PERMISSIONS = "defaultPermissions";

    private static final Set<PosixFilePermission> DEFAULT_PERMISSIONS =

        PosixFilePermissions.fromString("rwxrwxrwx");

    // Property used to specify the compression mode to use

    private static final String PROPERTY_COMPRESSION_METHOD = "compressionMethod";

    // Value specified for compressionMethod property to compress Zip entries

    private static final String COMPRESSION_METHOD_DEFLATED = "DEFLATED";

    // Value specified for compressionMethod property to not compress Zip entries

    private static final String COMPRESSION_METHOD_STORED = "STORED";

    private final ZipFileSystemProvider provider;

    private final Path zfpath;

    final ZipCoder zc;

    private final ZipPath rootdir;

    private boolean readOnly; // readonly file system, false by default

    // default time stamp for pseudo entries

    private final long zfsDefaultTimeStamp = System.currentTimeMillis();

    // configurable by env map

    private final boolean noExtt;        // see readExtra()

    private final boolean useTempFile;   // use a temp file for newOS, default

                                         // is to use BAOS for better performance

    private final boolean forceEnd64;

    private final int defaultCompressionMethod; // METHOD_STORED if "noCompression=true"

                                                // METHOD_DEFLATED otherwise

    // POSIX support

    final boolean supportPosix;

    private final UserPrincipal defaultOwner;

    private final GroupPrincipal defaultGroup;

    private final Set<PosixFilePermission> defaultPermissions;

    private final Set<String> supportedFileAttributeViews;

    ZipFileSystem(ZipFileSystemProvider provider,

                  Path zfpath,

                  Map<String, ?> env) throws IOException

    {

        // default encoding for name/comment

        String nameEncoding = env.containsKey("encoding") ?

            (String)env.get("encoding") : "UTF-8";

        this.noExtt = "false".equals(env.get("zipinfo-time"));

        this.useTempFile  = isTrue(env, "useTempFile");

        this.forceEnd64 = isTrue(env, "forceZIP64End");

        this.defaultCompressionMethod = getDefaultCompressionMethod(env);

        this.supportPosix = isTrue(env, PROPERTY_POSIX);

        this.defaultOwner = initOwner(zfpath, env);

        this.defaultGroup = initGroup(zfpath, env);

        this.defaultPermissions = initPermissions(env);

        this.supportedFileAttributeViews = supportPosix ?

            Set.of("basic", "posix", "zip") : Set.of("basic", "zip");

        if (Files.notExists(zfpath)) {

            // create a new zip if it doesn't exist

            if (isTrue(env, "create")) {

                try (OutputStream os = Files.newOutputStream(zfpath, CREATE_NEW, WRITE)) {

                    new END().write(os, 0, forceEnd64);

                }

            } else {

                throw new NoSuchFileException(zfpath.toString());

            }

        }

        // sm and existence check

        zfpath.getFileSystem().provider().checkAccess(zfpath, AccessMode.READ);

        boolean writeable = AccessController.doPrivileged(

            (PrivilegedAction<Boolean>)()->Files.isWritable(zfpath));

        this.readOnly = !writeable;

        this.zc = ZipCoder.get(nameEncoding);

        this.rootdir = new ZipPath(this, new byte[]{'/'});

        this.ch = Files.newByteChannel(zfpath, READ);

        try {

            this.cen = initCEN();

        } catch (IOException x) {

            try {

                this.ch.close();

            } catch (IOException xx) {

                x.addSuppressed(xx);

            }

            throw x;

        }

        this.provider = provider;

        this.zfpath = zfpath;

    }

    /**

     * Return the compression method to use (STORED or DEFLATED).  If the

     * property {@code commpressionMethod} is set use its value to determine

     * the compression method to use.  If the property is not set, then the

     * default compression is DEFLATED unless the property {@code noCompression}

     * is set which is supported for backwards compatibility.

     * @param env Zip FS map of properties

     * @return The Compression method to use

     */

    private int getDefaultCompressionMethod(Map<String, ?> env) {

        int result =

                isTrue(env, "noCompression") ? METHOD_STORED : METHOD_DEFLATED;

        if (env.containsKey(PROPERTY_COMPRESSION_METHOD)) {

            Object compressionMethod =  env.get(PROPERTY_COMPRESSION_METHOD);

            if (compressionMethod != null) {

                if (compressionMethod instanceof String) {

                    switch (((String) compressionMethod).toUpperCase()) {

                        case COMPRESSION_METHOD_STORED:

                            result = METHOD_STORED;

                            break;

                        case COMPRESSION_METHOD_DEFLATED:

                            result = METHOD_DEFLATED;

                            break;

                        default:

                            throw new IllegalArgumentException(String.format(

                                    "The value for the %s property must be %s or %s",

                                    PROPERTY_COMPRESSION_METHOD, COMPRESSION_METHOD_STORED,

                                    COMPRESSION_METHOD_DEFLATED));

                    }

                } else {

                    throw new IllegalArgumentException(String.format(

                            "The Object type for the %s property must be a String",

                            PROPERTY_COMPRESSION_METHOD));

                }

            } else {

                throw new IllegalArgumentException(String.format(

                        "The value for the %s property must be %s or %s",

                        PROPERTY_COMPRESSION_METHOD, COMPRESSION_METHOD_STORED,

                        COMPRESSION_METHOD_DEFLATED));

            }

        }

        return result;

    }

    // returns true if there is a name=true/"true" setting in env

    private static boolean isTrue(Map<String, ?> env, String name) {

        return "true".equals(env.get(name)) || TRUE.equals(env.get(name));

    }

    // Initialize the default owner for files inside the zip archive.

    // If not specified in env, it is the owner of the archive. If no owner can

    // be determined, we try to go with system property "user.name". If that's not

    // accessible, we return "<zipfs_default>".

    private UserPrincipal initOwner(Path zfpath, Map<String, ?> env) throws IOException {

        Object o = env.get(PROPERTY_DEFAULT_OWNER);

        if (o == null) {

            try {

                PrivilegedExceptionAction<UserPrincipal> pa = ()->Files.getOwner(zfpath);

                return AccessController.doPrivileged(pa);

            } catch (UnsupportedOperationException | PrivilegedActionException e) {

                if (e instanceof UnsupportedOperationException ||

                    e.getCause() instanceof NoSuchFileException)

                {

                    PrivilegedAction<String> pa = ()->System.getProperty("user.name");

                    String userName = AccessController.doPrivileged(pa);

                    return ()->userName;

                } else {

                    throw new IOException(e);

                }

            }

        }

        if (o instanceof String) {

            if (((String)o).isEmpty()) {

                throw new IllegalArgumentException("Value for property " +

                        PROPERTY_DEFAULT_OWNER + " must not be empty.");

            }

            return ()->(String)o;

        }

        if (o instanceof UserPrincipal) {

            return (UserPrincipal)o;

        }

        throw new IllegalArgumentException("Value for property " +

                PROPERTY_DEFAULT_OWNER + " must be of type " + String.class +

            " or " + UserPrincipal.class);

    }

    // Initialize the default group for files inside the zip archive.

    // If not specified in env, we try to determine the group of the zip archive itself.

    // If this is not possible/unsupported, we will return a group principal going by

    // the same name as the default owner.

    private GroupPrincipal initGroup(Path zfpath, Map<String, ?> env) throws IOException {

        Object o = env.get(PROPERTY_DEFAULT_GROUP);

        if (o == null) {

            try {

                PosixFileAttributeView zfpv = Files.getFileAttributeView(zfpath, PosixFileAttributeView.class);

                if (zfpv == null) {

                    return defaultOwner::getName;

                }

                PrivilegedExceptionAction<GroupPrincipal> pa = ()->zfpv.readAttributes().group();

                return AccessController.doPrivileged(pa);

            } catch (UnsupportedOperationException | PrivilegedActionException e) {

                if (e instanceof UnsupportedOperationException ||

                    e.getCause() instanceof NoSuchFileException)

                {

                    return defaultOwner::getName;

                } else {

                    throw new IOException(e);

                }

            }

        }

        if (o instanceof String) {

            if (((String)o).isEmpty()) {

                throw new IllegalArgumentException("Value for property " +

                        PROPERTY_DEFAULT_GROUP + " must not be empty.");

            }

            return ()->(String)o;

        }

        if (o instanceof GroupPrincipal) {

            return (GroupPrincipal)o;

        }

        throw new IllegalArgumentException("Value for property " +

                PROPERTY_DEFAULT_GROUP + " must be of type " + String.class +

            " or " + GroupPrincipal.class);

    }

    // Initialize the default permissions for files inside the zip archive.

    // If not specified in env, it will return 777.

    private Set<PosixFilePermission> initPermissions(Map<String, ?> env) {

        Object o = env.get(PROPERTY_DEFAULT_PERMISSIONS);

        if (o == null) {

            return DEFAULT_PERMISSIONS;

        }

        if (o instanceof String) {

            return PosixFilePermissions.fromString((String)o);

        }

        if (!(o instanceof Set)) {

            throw new IllegalArgumentException("Value for property " +

                PROPERTY_DEFAULT_PERMISSIONS + " must be of type " + String.class +

                " or " + Set.class);

        }

        Set<PosixFilePermission> perms = new HashSet<>();

        for (Object o2 : (Set<?>)o) {

            if (o2 instanceof PosixFilePermission) {

                perms.add((PosixFilePermission)o2);

            } else {

                throw new IllegalArgumentException(PROPERTY_DEFAULT_PERMISSIONS +

                    " must only contain objects of type " + PosixFilePermission.class);

            }

        }

        return perms;

    }

    @Override

    public FileSystemProvider provider() {

        return provider;

    }

    @Override

    public String getSeparator() {

        return "/";

    }

    @Override

    public boolean isOpen() {

        return isOpen;

    }

    @Override

    public boolean isReadOnly() {

        return readOnly;

    }

    private void checkWritable() {

        if (readOnly) {

            throw new ReadOnlyFileSystemException();

        }

    }

    void setReadOnly() {

        this.readOnly = true;

    }

    @Override

    public Iterable<Path> getRootDirectories() {

        return List.of(rootdir);

    }

    ZipPath getRootDir() {

        return rootdir;

    }

    @Override

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

        if (more.length == 0) {

            return new ZipPath(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 ZipPath(this, sb.toString());

    }

    @Override

    public UserPrincipalLookupService getUserPrincipalLookupService() {

        throw new UnsupportedOperationException();

    }

    @Override

    public WatchService newWatchService() {

        throw new UnsupportedOperationException();

    }

    FileStore getFileStore(ZipPath path) {

        return new ZipFileStore(path);

    }

    @Override

    public Iterable<FileStore> getFileStores() {

        return List.of(new ZipFileStore(rootdir));

    }

    @Override

    public Set<String> supportedFileAttributeViews() {

        return supportedFileAttributeViews;

    }

    @Override

    public String toString() {

        return zfpath.toString();

    }

    Path getZipFile() {

        return zfpath;

    }

    private static final String GLOB_SYNTAX = "glob";

    private static final String REGEX_SYNTAX = "regex";

    @Override

    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_SYNTAX)) {

            expr = toRegexPattern(input);

        } else {

            if (syntax.equalsIgnoreCase(REGEX_SYNTAX)) {

                expr = input;

            } else {

                throw new UnsupportedOperationException("Syntax '" + syntax +

                    "' not recognized");

            }

        }

        // return matcher

        final Pattern pattern = Pattern.compile(expr);

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

    }

    @Override

    public void close() throws IOException {

        beginWrite();

        try {

            if (!isOpen)

                return;

            isOpen = false;          // set closed

        } finally {

            endWrite();

        }

        if (!streams.isEmpty()) {    // unlock and close all remaining streams

            Set<InputStream> copy = new HashSet<>(streams);

            for (InputStream is : copy)

                is.close();

        }

        beginWrite();                // lock and sync

        try {

            AccessController.doPrivileged((PrivilegedExceptionAction<Void>)() -> {

                sync(); return null;

            });

            ch.close();              // close the ch just in case no update

                                     // and sync didn't close the ch

        } catch (PrivilegedActionException e) {

            throw (IOException)e.getException();

        } finally {

            endWrite();

        }

        synchronized (inflaters) {

            for (Inflater inf : inflaters)

                inf.end();

        }

        synchronized (deflaters) {

            for (Deflater def : deflaters)

                def.end();

        }

        IOException ioe = null;

        synchronized (tmppaths) {

            for (Path p : tmppaths) {