/*

 * Copyright (c) 2012, 2018, 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.

 *

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

 */

/* @test

 * @bug 7156873 8040059 8028480 8034773 8153248 8061777 8197398 8210394

 * @summary ZipFileSystem regression tests

 *

 * @modules jdk.zipfs

 * @run main ZFSTests

 * @run main/othervm/java.security.policy=test.policy ZFSTests

 */

import java.io.IOException;

import java.io.OutputStream;

import java.net.URI;

import java.nio.ByteBuffer;

import java.nio.channels.*;

import java.nio.file.*;

import java.nio.file.attribute.BasicFileAttributes;

import java.nio.file.spi.*;

import java.util.*;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import java.util.zip.ZipOutputStream;

public class ZFSTests {

    public static void main(String[] args) throws Throwable {

        test8197398();

        test7156873();

        test8061777();

        tests();

    }

    static void test8197398() throws Throwable {

        // root entry "/"

        Path path = Paths.get("rootdir.zip");

        URI uri = URI.create("jar:" + path.toUri());

        Set<String> dirs = new HashSet<>();

        Set<String> files = new HashSet<>();

        try (OutputStream os = Files.newOutputStream(path);

             ZipOutputStream zos = new ZipOutputStream(os)) {

            zos.putNextEntry(new ZipEntry("/"));     dirs.add("/");

            zos.putNextEntry(new ZipEntry("foo"));   files.add("/foo");

            zos.write("/foo".getBytes());

            zos.putNextEntry(new ZipEntry("bar"));   files.add("/bar");

            zos.write("/bar".getBytes());

        }

        AtomicInteger cnt = new AtomicInteger();

        int max = 3;

        try (FileSystem fs = FileSystems.newFileSystem(uri, Collections.emptyMap())) {

            Files.walkFileTree(fs.getRootDirectories().iterator().next(),

                                new SimpleFileVisitor<Path>() {

                @Override

                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)

                        throws IOException {

                    if (cnt.incrementAndGet() > max)

                        throw new RuntimeException("visited too many files/dirs");

                    files.remove(file.toString());

                    if (!Arrays.equals(Files.readAllBytes(file), file.toString().getBytes()))

                        throw new RuntimeException("visited files has wrong content: " + file);

                    return FileVisitResult.CONTINUE;

                }

                @Override

                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)

                        throws IOException {

                    if (cnt.incrementAndGet() > max)

                        throw new RuntimeException("visited too many files/dirs");

                    dirs.remove(dir.toString());

                    return FileVisitResult.CONTINUE;

                }

            });

            if (cnt.get() != max || dirs.size() != 0 || files.size() != 0)

                throw new RuntimeException("walk files/dirs failed");

        } finally {

            Files.deleteIfExists(path);

        }

        // absolute file/dir, no need to test cnt again..

        dirs.clear();

        files.clear();

        try {

            try (OutputStream os = Files.newOutputStream(path);

                ZipOutputStream zos = new ZipOutputStream(os)) {

                zos.putNextEntry(new ZipEntry("/"));     dirs.add("/");

                zos.putNextEntry(new ZipEntry("/fooo/"));     dirs.add("/fooo");

                zos.putNextEntry(new ZipEntry("/foo"));   files.add("/foo");

                zos.write("/foo".getBytes());

                zos.putNextEntry(new ZipEntry("/bar"));   files.add("/bar");

                zos.write("/bar".getBytes());

                zos.putNextEntry(new ZipEntry("/fooo/bar"));   files.add("/fooo/bar");

                zos.write("/fooo/bar".getBytes());

            }

            try (FileSystem fs = FileSystems.newFileSystem(uri, Collections.emptyMap())) {

                Files.walkFileTree(fs.getRootDirectories().iterator().next(),

                                    new SimpleFileVisitor<Path>() {

                    @Override

                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)

                            throws IOException {

                        files.remove(file.toString());

                        if (!Arrays.equals(Files.readAllBytes(file), file.toString().getBytes()))

                            throw new RuntimeException("visited files has wrong content: " + file);

                        return FileVisitResult.CONTINUE;

                    }

                    @Override

                    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)

                            throws IOException {

                        dirs.remove(dir.toString());

                        return FileVisitResult.CONTINUE;

                    }

                });

                if (dirs.size() != 0 || files.size() != 0)

                    throw new RuntimeException("walk files/dirs failed");

                // for next test: updated any entry, the result zipfs file should have no

                // absolute path entry

                Files.write(fs.getPath("/foo"), "/foo".getBytes());

            }

            // updated zfs should have the same dirs/files (path is not absolute though)

            dirs.add("/");

            dirs.add("/fooo");

            files.add("/foo");

            files.add("/bar");

            files.add("/fooo/bar");

            try (FileSystem fs = FileSystems.newFileSystem(uri, Collections.emptyMap())) {

                    Files.walk(fs.getPath("/")).forEach( p -> {

                        if (Files.isDirectory(p)) {

                            dirs.remove(p.toString());

                        } else {

                            files.remove(p.toString());

                            try {

                                if (!Arrays.equals(Files.readAllBytes(p), p.toString().getBytes()))

                                    throw new RuntimeException("visited files has wrong content: " + p);

                            } catch (IOException x) {

                                throw new RuntimeException(x);

                            }

                        }

                    });

                if (dirs.size() != 0 || files.size() != 0)

                    throw new RuntimeException("walk files/dirs failed");

            }

            // updated zip file should  not have "/" and entry with absolute path

            try (var zf = new ZipFile(path.toFile())) {

                String[] entries = zf.stream()

                                     .map(ZipEntry::toString)

                                     .sorted()

                                     .toArray(String[]::new);

                if (!Arrays.equals(entries, new String[] {"bar", "foo", "fooo/", "fooo/bar" })) {

                    System.out.println("unexpeded: " + Arrays.toString(entries));

                    throw new RuntimeException("unexpected entreis in updated zipfs file");

                }

            }

        } finally {

            Files.deleteIfExists(path);

        }

    }

    static void test7156873() throws Throwable {

        String DIRWITHSPACE = "testdir with spaces";

        Path dir = Paths.get(DIRWITHSPACE);

        Path path = Paths.get(DIRWITHSPACE, "file.zip");

        try {

            Files.createDirectory(dir);

            URI uri = URI.create("jar:" + path.toUri());

            Map<String, Object> env = new HashMap<String, Object>();

            env.put("create", "true");

            try (FileSystem fs = FileSystems.newFileSystem(uri, env)) {}

        } finally {

            Files.deleteIfExists(path);

            Files.deleteIfExists(dir);

        }

    }

    static void test8061777() throws Throwable {

        Path path = Paths.get("file.zip");

        try {

            URI uri = URI.create("jar:" + path.toUri());

            Map<String, Object> env = new HashMap<String, Object>();

            env.put("create", "true");

            env.put("encoding", "Shift_JIS");

            try (FileSystem fs = FileSystems.newFileSystem(uri, env)) {

                FileSystemProvider fsp = fs.provider();

                Path p = fs.getPath("/\u8868\u7533.txt");  // 0x95 0x5c 0x90 0x5c

                try (OutputStream os = fsp.newOutputStream(p)) {

                    os.write("Hello!".getBytes("ASCII"));

                }

                Path dir = fs.getPath("/");

                Files.list(dir)

                     .forEach( child -> {

                             System.out.println("child:" + child);

                             if (!child.toString().equals(p.toString()))

                                 throw new RuntimeException("wrong path name created");

                          });

                if (!"Hello!".equals(new String(Files.readAllBytes(p), "ASCII")))

                    throw new RuntimeException("wrong content in newly created file");

            }

        } finally {

            Files.deleteIfExists(path);

        }

    }

    static void tests() throws Throwable {

        Path path = Paths.get("file.zip");

        try {

            URI uri = URI.create("jar:" + path.toUri());

            Map<String, Object> env = new HashMap<String, Object>();

            env.put("create", "true");

            try (FileSystem fs = FileSystems.newFileSystem(uri, env)) {

                FileSystemProvider fsp = fs.provider();

                Set<? extends OpenOption> options;

                Path p = fs.getPath("test.txt");

                // 8028480

                options = EnumSet.of(StandardOpenOption.CREATE,

                                     StandardOpenOption.WRITE,

                                     StandardOpenOption.APPEND);

                try (FileChannel ch = fsp.newFileChannel(p, options)) {

                    ch.write(ByteBuffer.wrap("Hello!".getBytes("ASCII")));

                }

                // 8034773

                try (OutputStream os = fsp.newOutputStream(p, new OpenOption[0])) {

                    os.write("Hello2!".getBytes("ASCII"));

                }

                if (!"Hello2!".equals(new String(

                        Files.readAllBytes(fs.getPath("test.txt"))))) {

                    throw new RuntimeException("failed to open as truncate_existing");

                }

                options = EnumSet.of(StandardOpenOption.CREATE,

                                     StandardOpenOption.APPEND,

                                     StandardOpenOption.TRUNCATE_EXISTING);

                try (FileChannel ch = fsp.newFileChannel(p, options)) {

                    throw new RuntimeException("expected IAE not thrown!");

                } catch (IllegalArgumentException x) {

                    // expected x.printStackTrace();

                }

                //8153248

                Path dir = fs.getPath("/dir");

                Path subdir = fs.getPath("/dir/subdir");

                Files.createDirectory(dir);

                Files.createDirectory(subdir);

                Files.list(dir)

                     .forEach( child -> {

                             System.out.println("child:" + child);

                             if (child.toString().endsWith("/"))

                                 throw new RuntimeException("subdir names ends with /");

                          });

            }

        } finally {

            Files.deleteIfExists(path);

        }

    }

}