/*

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

import java.io.BufferedOutputStream;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.EOFException;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.nio.ByteBuffer;

import java.nio.MappedByteBuffer;

import java.nio.channels.*;

import java.nio.file.*;

import java.nio.file.attribute.*;

import java.nio.file.spi.*;

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.Inflater;

import java.util.zip.Deflater;

import java.util.zip.InflaterInputStream;

import java.util.zip.DeflaterOutputStream;

import java.util.zip.ZipException;

import static java.lang.Boolean.*;

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

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

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

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

/**

 * A FileSystem built on a zip file

 *

 * @author Xueming Shen

 */

class ZipFileSystem extends FileSystem {

    private final ZipFileSystemProvider provider;

    private final Path zfpath;

    final ZipCoder zc;

    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 static final boolean isWindows = AccessController.doPrivileged(

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

                                                    .startsWith("Windows"));

    private final boolean forceEnd64;

    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"));

        if (Files.notExists(zfpath)) {

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

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

                }

            } else {

                throw new FileSystemNotFoundException(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;

        }

    }

    @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() throws IOException {

        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));

    }

    private static final Set<String> supportedFileAttributeViews =

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

    @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 new PathMatcher() {

            @Override

            public boolean matches(Path path) {

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

            }

        };

    }

    @Override

    public void close() throws IOException {

        beginWrite();

        try {

            if (!isOpen)

                return;

        } finally {

            endWrite();

        }

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

            for (InputStream is: copy)

                is.close();

        }

        try {

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

                sync(); return null;

            });

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

                try {

                    AccessController.doPrivileged(

                        (PrivilegedExceptionAction<Boolean>)() -> Files.deleteIfExists(p));

                } catch (PrivilegedActionException e) {

                    IOException x = (IOException)e.getException();

                    if (ioe == null)

                        ioe = x;

                    else

                        ioe.addSuppressed(x);

                }

            }

        }

        provider.removeFileSystem(zfpath, this);

        if (ioe != null)

           throw ioe;

    }

    ZipFileAttributes getFileAttributes(byte[] path)

        throws IOException

    {

        Entry e;

        beginRead();

        try {

            ensureOpen();

            e = getEntry(path);

            if (e == null) {

                IndexNode inode = getInode(path);

                if (inode == null)

                    return null;

                e.mtime = e.atime = e.ctime = zfsDefaultTimeStamp;

            }

        } finally {

            endRead();

        }

        return e;

    }

    void checkAccess(byte[] path) throws IOException {

        beginRead();

        try {

            ensureOpen();

            // is it necessary to readCEN as a sanity check?

            if (getInode(path) == null) {

                throw new NoSuchFileException(toString());

            }

        } finally {

            endRead();

        }

    }

    void setTimes(byte[] path, FileTime mtime, FileTime atime, FileTime ctime)

        throws IOException

    {

        checkWritable();

        beginWrite();

        try {

            ensureOpen();

            Entry e = getEntry(path);    // ensureOpen checked

            if (e == null)

                throw new NoSuchFileException(getString(path));

            if (e.type == Entry.CEN)

                e.type = Entry.COPY;      // copy e

            if (mtime != null)

                e.mtime = mtime.toMillis();

            if (atime != null)

                e.atime = atime.toMillis();

            if (ctime != null)

                e.ctime = ctime.toMillis();

            update(e);

        } finally {

            endWrite();

        }

    }

    boolean exists(byte[] path)

        throws IOException

    {

        beginRead();

        try {

            ensureOpen();

            return getInode(path) != null;

        } finally {

            endRead();

        }

    }

    boolean isDirectory(byte[] path)

        throws IOException

    {

        beginRead();

        try {

            IndexNode n = getInode(path);

            return n != null && n.isDir();

        } finally {

            endRead();

        }

    }

    // returns the list of child paths of "path"

    Iterator<Path> iteratorOf(byte[] path,

                              DirectoryStream.Filter<? super Path> filter)

        throws IOException

    {

        beginWrite();    // iteration of inodes needs exclusive lock

        try {

            ensureOpen();

            IndexNode inode = getInode(path);

            if (inode == null)

                throw new NotDirectoryException(getString(path));

            List<Path> list = new ArrayList<>();

            IndexNode child = inode.child;

            while (child != null) {

                // assume all path from zip file itself is "normalized"

                ZipPath zp = new ZipPath(this, child.name, true);

                if (filter == null || filter.accept(zp))

                    list.add(zp);

                child = child.sibling;

            }

            return list.iterator();

        } finally {

            endWrite();

        }

    }

    void createDirectory(byte[] dir, FileAttribute<?>... attrs)

        throws IOException

    {

        checkWritable();

        //  dir = toDirectoryPath(dir);

        beginWrite();

        try {

            ensureOpen();

            if (dir.length == 0 || exists(dir))  // root dir, or exiting dir

                throw new FileAlreadyExistsException(getString(dir));

            checkParents(dir);

            update(e);

        } finally {

            endWrite();

        }

    }

    void copyFile(boolean deletesrc, byte[]src, byte[] dst, CopyOption... options)

        throws IOException

    {

        checkWritable();

        if (Arrays.equals(src, dst))

            return;    // do nothing, src and dst are the same

        beginWrite();

        try {

            ensureOpen();

            Entry eSrc = getEntry(src);  // ensureOpen checked

            if (eSrc == null)

                throw new NoSuchFileException(getString(src));

            if (eSrc.isDir()) {    // spec says to create dst dir

                createDirectory(dst);

                return;

            }

            boolean hasReplace = false;

            boolean hasCopyAttrs = false;

            for (CopyOption opt : options) {

                if (opt == REPLACE_EXISTING)

                    hasReplace = true;

                else if (opt == COPY_ATTRIBUTES)

                    hasCopyAttrs = true;

            }

            Entry eDst = getEntry(dst);

            if (eDst != null) {

                if (!hasReplace)

                    throw new FileAlreadyExistsException(getString(dst));

            } else {

                checkParents(dst);

            }

            Entry u = new Entry(eSrc, Entry.COPY);  // copy eSrc entry

            if (eSrc.type == Entry.NEW || eSrc.type == Entry.FILECH)

            {

                u.type = eSrc.type;    // make it the same type

                if (deletesrc) {       // if it's a "rename", take the data

                    u.bytes = eSrc.bytes;

                    u.file = eSrc.file;

                } else {               // if it's not "rename", copy the data

                    if (eSrc.bytes != null)

                        u.bytes = Arrays.copyOf(eSrc.bytes, eSrc.bytes.length);

                    else if (eSrc.file != null) {

                        u.file = getTempPathForEntry(null);

                        Files.copy(eSrc.file, u.file, REPLACE_EXISTING);

                    }

                }

            }

            if (!hasCopyAttrs)

                u.mtime = u.atime= u.ctime = System.currentTimeMillis();

            update(u);

            if (deletesrc)

                updateDelete(eSrc);

        } finally {

            endWrite();

        }