/*

 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 *   - Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *

 *   - Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 *   - Neither the name of Oracle nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package com.sun.nio.zipfs;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.EOFException;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.MappedByteBuffer;

import java.nio.channels.*;

import java.nio.file.*;

import java.nio.file.attribute.*;

import java.nio.file.spi.*;

import java.net.URI;

import java.util.*;

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 java.util.zip.ZipError;

import static java.lang.Boolean.*;

import static com.sun.nio.zipfs.ZipConstants.*;

import static com.sun.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

 */

public class ZipFileSystem extends FileSystem {

    private final ZipFileSystemProvider provider;

    private final ZipPath defaultdir;

    private boolean readOnly = false;

    private final Path zfpath;

    private final ZipCoder zc;

    private final Object lock = new Object();

    // configurable by env map

    private final String  defaultDir;    // default dir for the file system

    private final String  nameEncoding;  // default encoding for name/comment

    private final boolean buildDirTree;  // build a dir tree for directoryStream ops

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

                                         // is to use BAOS for better performance

    private final boolean createNew;     // create a new zip if not exists

    ZipFileSystem(ZipFileSystemProvider provider,

                  Path zfpath,

                  Map<String, ?> env)

        throws IOException

    {

        // configurable env setup

        this.buildDirTree = TRUE.equals(env.get("buildDirTree"));

        this.useTempFile = TRUE.equals(env.get("useTempFile"));

        this.createNew = TRUE.equals(env.get("createNew"));

        this.nameEncoding = env.containsKey("nameEncoding") ?

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

        this.defaultDir = env.containsKey("default.dir") ?

                          (String)env.get("default.dir") : "/";

        if (this.defaultDir.charAt(0) != '/')

            throw new IllegalArgumentException("default dir should be absolute");

        this.provider = provider;

        this.zfpath = zfpath;

        if (zfpath.notExists()) {

            if (createNew) {

                OutputStream os = zfpath.newOutputStream(CREATE_NEW, WRITE);

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

                os.close();

            } else {

                throw new FileSystemNotFoundException(zfpath.toString());

            }

        }

        zfpath.checkAccess(AccessMode.READ); // sm and existence check

        try {

            zfpath.checkAccess(AccessMode.WRITE);

        } catch (AccessDeniedException x) {

            this.readOnly = true;

        }

        this.zc = ZipCoder.get(nameEncoding);

        this.defaultdir = new ZipPath(this, getBytes(defaultDir));

        initZipFile();

    }

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

    }

    @Override

    public Iterable<Path> getRootDirectories() {

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

        pathArr.add(new ZipPath(this, new byte[]{'/'}));

        return pathArr;

    }

    ZipPath getDefaultDir() {  // package private

        return defaultdir;

    }

    @Override

    public ZipPath getPath(String path) {

        if (path.length() == 0)

            throw new InvalidPathException(path, "path should not be empty");

        return new ZipPath(this, getBytes(path));

    }

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

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

        list.add(new ZipFileStore(new ZipPath(this, new byte[]{'/'})));

        return list;

    }

    private static final Set<String> supportedFileAttributeViews =

            Collections.unmodifiableSet(

                new HashSet<String>(Arrays.asList("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.equals(GLOB_SYNTAX)) {

            expr = toRegexPattern(input);

        } else {

            if (syntax.equals(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 {

        synchronized (lock) {

            if (!isOpen)

                return;

            isOpen = false;

            if (!streams.isEmpty()) {

                synchronized(streams) {

                    for (InputStream is: streams)

                    is.close();

                }

            }

            sync();

            ch.close();

        }

        synchronized (inflaters) {

            for (Inflater inf : inflaters)

                inf.end();

        }

        synchronized (deflaters) {

            for (Deflater def : deflaters)

                def.end();

        }

        for (Path p: tmppaths) {

            try {

                p.deleteIfExists();

            } catch (IOException x) {

                x.printStackTrace();

            }

        }

        provider.removeFileSystem(zfpath);

    }

    ZipFileAttributes[] getAllAttributes() throws IOException {

        ensureOpen();

        int n = inodes.size();

        ZipFileAttributes[] zes = new ZipFileAttributes[n];

        Iterator<IndexNode> itr = inodes.values().iterator();

        int i = 0;

        while(itr.hasNext()) {

            zes[i++] = new ZipFileAttributes(Entry.readCEN(cen, itr.next().pos));

        }

        return zes;

    }

    EntryName[] getEntryNames() throws IOException {

        ensureOpen();

        return inodes.keySet().toArray(new EntryName[0]);

    }

    ZipFileAttributes getFileAttributes(byte[] path)

        throws IOException

    {

        synchronized (lock) {

            Entry e = getEntry0(path);

            if (e == null) {

                if (path.length == 0) {

                    e = new Entry(new byte[0]);  // root

                } else if (buildDirTree) {

                    IndexNode inode = getDirs().get(new EntryName(path));

                    if (inode == null)

                        return null;

                    e = new Entry(inode.name);

                } else {

                    return null;

                }

                e.method = METHOD_STORED;        // STORED for dir

                BasicFileAttributes bfas = Attributes.readBasicFileAttributes(zfpath);

                if (bfas.lastModifiedTime() != null)

                    e.mtime = javaToDosTime(bfas.lastModifiedTime().toMillis());

                if (bfas.lastAccessTime() != null)

                    e.atime = javaToDosTime(bfas.lastAccessTime().toMillis());

                if (bfas.creationTime() != null)

                    e.ctime = javaToDosTime(bfas.creationTime().toMillis());

            }

            return new ZipFileAttributes(e);

        }

    }

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

        throws IOException

    {

        checkWritable();

        synchronized (lock) {

            Entry e = getEntry0(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 = javaToDosTime(mtime.toMillis());

            if (atime != null)

                e.atime = javaToDosTime(atime.toMillis());

            if (ctime != null)

                e.ctime = javaToDosTime(ctime.toMillis());

            update(e);

        }

    }

    boolean exists(byte[] path)

        throws IOException

    {

        return getEntry0(path) != null;

    }

    boolean isDirectory(byte[] path)

        throws IOException

    {

        synchronized (lock) {

            if (buildDirTree) {

                return getDirs().containsKey(new EntryName(path));

            }

            Entry e = getEntry0(path);

            return (e != null && e.isDir()) || path.length == 0;

        }

    }

    private ZipPath toZipPath(byte[] path) {

        // make it absolute

        byte[] p = new byte[path.length + 1];

        p[0] = '/';

        System.arraycopy(path, 0, p, 1, path.length);

        return new ZipPath(this, p);

    }

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

    Iterator<Path> iteratorOf(byte[] path,

                              DirectoryStream.Filter<? super Path> filter)

        throws IOException

    {

        synchronized (lock) {

            if (buildDirTree) {

                IndexNode inode = getDirs().get(new EntryName(path));

                if (inode == null)

                    throw new NotDirectoryException(getString(path));

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

                IndexNode child = inode.child;

                while (child != null) {

                    ZipPath zp = toZipPath(child.name);

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

                        list.add(zp);

                    child = child.sibling;

                }

                return list.iterator();

            }

            if (!isDirectory(path))

                throw new NotDirectoryException(getString(path));

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

            EntryName[] entries = getEntryNames();

            path = toDirectoryPath(path);

            for (EntryName en :entries) {

                if (!isParentOf(path, en.name))  // is "path" the parent of "name"

                    continue;

                int off = path.length;

                while (off < en.name.length) {

                    if (en.name[off] == '/')

                        break;

                    off++;

                }

                if (off < (en.name.length - 1))

                    continue;

                ZipPath zp = toZipPath(en.name);

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

                    list.add(zp);

            }

            return list.iterator();

        }

    }

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

        throws IOException

    {

        checkWritable();

        dir = toDirectoryPath(dir);

        synchronized (lock) {

            ensureOpen();

            // pseudo root dir, or exiting dir

            if (dir.length == 0 || exists(dir))

                throw new FileAlreadyExistsException(getString(dir));

            checkParents(dir);

            Entry e = new Entry(dir, Entry.NEW);

            e.method = METHOD_STORED;  // STORED for dir

            update(e);

        }

    }

    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

        synchronized (lock) {

            Entry eSrc = getEntry0(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 = getEntry0(dst);

            if (eDst != null) {

                if (!hasReplace)

                    throw new FileAlreadyExistsException(getString(dst));

            } else {

                checkParents(dst);

            }

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

            u.name = dst;                             // change name

            // don't touch the "nlen and elen" here. writeLOC() always

            // re-calculate from "name" and "extra" for the correct length,

            // copyLOCEntry however needs the original lengths to skip the

            // loc header.

            // u.nlen = dst.length;

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

            {

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

                if (!deletesrc) {      // if it's not "rename", just take the data

                    if (eSrc.bytes != null)

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

                    else if (eSrc.file != null) {

                        u.file = getTempPathForEntry(null);

                        eSrc.file.copyTo(u.file, REPLACE_EXISTING);

                    }

                }

            }

            if (!hasCopyAttrs)

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

            update(u);

            if (deletesrc)

                updateDelete(eSrc);

        }

    }

    // Returns an output stream for writing the contents into the specified

    // entry.

    OutputStream newOutputStream(byte[] path, OpenOption... options)

        throws IOException

    {

        checkWritable();

        boolean hasCreateNew = false;

        boolean hasCreate = false;

        boolean hasAppend = false;

        for (OpenOption opt: options) {

            if (opt == READ)

                throw new IllegalArgumentException("READ not allowed");

            if (opt == CREATE_NEW)

                hasCreateNew = true;

            if (opt == CREATE)

                hasCreate = true;

            if (opt == APPEND)

                hasAppend = true;

        }

        synchronized (lock) {

            Entry e = getEntry0(path);

            if (e != null) {

                if (e.isDir() || hasCreateNew)

                    throw new FileAlreadyExistsException(getString(path));

                if (hasAppend) {

                    InputStream is = getInputStream(e);

                    OutputStream os = getOutputStream(new Entry(e, Entry.NEW));

                    copyStream(is, os);

                    is.close();

                    return os;

                 }

                 return getOutputStream(new Entry(e, Entry.NEW));

            } else {

                if (!hasCreate && !hasCreateNew)

                    throw new NoSuchFileException(getString(path));

                checkParents(path);

                return getOutputStream(new Entry(path, Entry.NEW));

            }

        }

    }

    // Returns an input stream for reading the contents of the specified

    // file entry.

    InputStream newInputStream(byte[] path) throws IOException {

        synchronized (lock) {