/*

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

    // 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 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

    private static final boolean isWindows =

        System.getProperty("os.name").startsWith("Windows");

    ZipFileSystem(ZipFileSystemProvider provider,

                  Path zfpath,

                  Map<String, ?> env)

        throws IOException

    {

        // configurable env setup

        this.createNew    = "true".equals(env.get("create"));

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

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

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

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

        this.ch = zfpath.newByteChannel(READ);

        this.cen = initCEN();

    }

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

        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 {

            sync();

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

        } finally {                     // and sync dose not close the ch

            endWrite();

        }

        synchronized (inflaters) {

            for (Inflater inf : inflaters)

                inf.end();

        }

        synchronized (deflaters) {

            for (Deflater def : deflaters)

                def.end();

        }

        synchronized (tmppaths) {

            for (Path p: tmppaths) {

                try {

                    p.deleteIfExists();

                } catch (IOException x) {

                    x.printStackTrace();

                }

            }

        }

        provider.removeFileSystem(zfpath);

    }

    ZipFileAttributes getFileAttributes(byte[] path)

        throws IOException

    {

        Entry e;

        beginRead();

        try {

            ensureOpen();

            e = getEntry0(path);

                if (inode == null)

                    return null;

            }

        }

        return new ZipFileAttributes(e);

    }

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

        throws IOException

    {

        checkWritable();

        beginWrite();

        try {

            ensureOpen();

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

        } finally {

            endRead();

        }

    }

    boolean isDirectory(byte[] path)

        throws IOException

    {

        beginRead();

        try {

        } finally {

            endRead();

        }

    }

    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

    {

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

        try {

            ensureOpen();

                throw new NotDirectoryException(getString(path));

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

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

                    list.add(zp);

            }

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

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

            e.method = METHOD_STORED;            // STORED for 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 = 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

            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 = System.currentTimeMillis();

            update(u);

            if (deletesrc)

                updateDelete(eSrc);

        } finally {

            endWrite();

        }

    }

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

        }

        try {                        // try to obtain a writelock when the os is

            ensureOpen();            // being closed.

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

            }

        } finally {

            endRead();

        }

    }

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

    // file entry.

    InputStream newInputStream(byte[] path) throws IOException {

        beginRead();

        try {

            ensureOpen();

            Entry e = getEntry0(path);

            if (e == null)

                throw new NoSuchFileException(getString(path));

            if (e.isDir())

                throw new FileSystemException(getString(path), "is a directory", null);