/*

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

 *

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

 */

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URI;

import java.net.URLDecoder;

import java.nio.ByteBuffer;

import java.nio.channels.Channels;

import java.nio.channels.FileChannel;

import java.nio.channels.SeekableByteChannel;

import java.nio.file.DirectoryStream;

import java.nio.file.FileAlreadyExistsException;

import java.nio.file.FileSystem;

import java.nio.file.FileSystemAlreadyExistsException;

import java.nio.file.FileSystemException;

import java.nio.file.FileSystems;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.OpenOption;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributeView;

import java.nio.file.attribute.BasicFileAttributes;

import java.nio.file.spi.FileSystemProvider;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Random;

import java.util.Set;

import java.util.concurrent.TimeUnit;

import java.util.zip.CRC32;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import java.util.zip.ZipOutputStream;

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

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

/*

 * Tests various zipfs operations.

 *

 * @test

 * @bug 6990846 7009092 7009085 7015391 7014948 7005986 7017840 7007596

 *      7157656 8002390 7012868 7012856 8015728 8038500 8040059 8069211

 *      8131067 8034802 8210899

 * @summary Test Zip filesystem provider

 * @modules jdk.zipfs

 * @run main ZipFSTester

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

 */

public class ZipFSTester {

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

        // create JAR file for test, actual contents don't matter

        Path jarFile = Utils.createJarFile("tester.jar",

                "META-INF/MANIFEST.MF",

                "dir1/foo",

                "dir2/bar",

                "dir1/dir3/fooo");

        try (FileSystem fs = newZipFileSystem(jarFile, Collections.emptyMap())) {

            test0(fs);

            test1(fs);

            test2(fs);   // more tests

        }

        testStreamChannel();

        testTime(jarFile);

        test8069211();

        test8131067();

    }

    private static Random rdm = new Random();

    static void test0(FileSystem fs)

        throws Exception

    {

        List<String> list = new LinkedList<>();

        try (ZipFile zf = new ZipFile(fs.toString())) {

            Enumeration<? extends ZipEntry> zes = zf.entries();

            while (zes.hasMoreElements()) {

                list.add(zes.nextElement().getName());

            }

            for (String pname : list) {

                Path path = fs.getPath(pname);

                if (!Files.exists(path))

                    throw new RuntimeException("path existence check failed!");

                while ((path = path.getParent()) != null) {

                    if (!Files.exists(path))

                        throw new RuntimeException("parent existence check failed!");

                }

            }

        }

    }

    static void test1(FileSystem fs0)

        throws Exception

    {

        // prepare a src for testing

        Path src = getTempPath();

        String tmpName = src.toString();

        try (OutputStream os = Files.newOutputStream(src)) {

            byte[] bits = new byte[12345];

            rdm.nextBytes(bits);

            os.write(bits);

        }

        // clone a fs from fs0 and test on it

        Path tmpfsPath = getTempPath();

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

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

        try (FileSystem copy = newZipFileSystem(tmpfsPath, env)) {

            z2zcopy(fs0, copy, "/", 0);

            // copy the test jar itself in

            Files.copy(Paths.get(fs0.toString()), copy.getPath("/foo.jar"));

            Path zpath = copy.getPath("/foo.jar");

            try (FileSystem zzfs = FileSystems.newFileSystem(zpath)) {

                Files.copy(src, zzfs.getPath("/srcInjarjar"));

            }

        }

        try (FileSystem fs = newZipFileSystem(tmpfsPath, new HashMap<String, Object>())) {

            FileSystemProvider provider = fs.provider();

            // newFileSystem(path...) should not throw exception

            try (FileSystem fsPath = provider.newFileSystem(tmpfsPath, new HashMap<String, Object>())){}

            try (FileSystem fsUri = provider.newFileSystem(

                     new URI("jar", tmpfsPath.toUri().toString(), null),

                     new HashMap<String, Object>()))

            {

                throw new RuntimeException("newFileSystem(URI...) does not throw exception");

            } catch (FileSystemAlreadyExistsException fsaee) {}

            try {

                provider.newFileSystem(new File(System.getProperty("test.src", ".")).toPath(),

                                       new HashMap<String, Object>());

                throw new RuntimeException("newFileSystem() opens a directory as zipfs");

            } catch (UnsupportedOperationException uoe) {}

            try {

                provider.newFileSystem(src, new HashMap<String, Object>());

                throw new RuntimeException("newFileSystem() opens a non-zip file as zipfs");

            } catch (UnsupportedOperationException uoe) {}

            // walk

            walk(fs.getPath("/"));

            // copyin

            Path dst = getPathWithParents(fs, tmpName);

            Files.copy(src, dst);

            checkEqual(src, dst);

            // copy

            Path dst2 = getPathWithParents(fs, "/xyz" + rdm.nextInt(100) +

                                           "/efg" + rdm.nextInt(100) + "/foo.class");

            Files.copy(dst, dst2);

            //dst.moveTo(dst2);

            checkEqual(src, dst2);

            // delete

            Files.delete(dst);

            if (Files.exists(dst))

                throw new RuntimeException("Failed!");

            // moveout

            Path dst3 = Paths.get(tmpName + "_Tmp");

            Files.move(dst2, dst3);

            checkEqual(src, dst3);

            if (Files.exists(dst2))

                throw new RuntimeException("Failed!");

            // copyback + move

            Files.copy(dst3, dst);

            Path dst4 = getPathWithParents(fs, tmpName + "_Tmp0");

            Files.move(dst, dst4);

            checkEqual(src, dst4);

            // delete

            Files.delete(dst4);

            if (Files.exists(dst4))

                throw new RuntimeException("Failed!");

            Files.delete(dst3);

            if (Files.exists(dst3))

                throw new RuntimeException("Failed!");

            // move (existing entry)

            Path dst5 = fs.getPath("META-INF/MANIFEST.MF");

            if (Files.exists(dst5)) {

                Path dst6 = fs.getPath("META-INF/MANIFEST.MF_TMP");

                Files.move(dst5, dst6);

                walk(fs.getPath("/"));

            }

            // newInputStream on dir

            Path parent = dst2.getParent();

            try {

                Files.newInputStream(parent);

                throw new RuntimeException("Failed");

            } catch (FileSystemException e) {

                // expected fse

            }

            // rmdirs

            try {

                rmdirs(parent);

            } catch (IOException x) {

                x.printStackTrace();

            }

            // newFileChannel() copy in, out and verify via fch

            fchCopy(src, dst);    // in

            checkEqual(src, dst);

            Path tmp = Paths.get(tmpName + "_Tmp");

            fchCopy(dst, tmp);   //  out

            checkEqual(src, tmp);

            Files.delete(tmp);

            // test channels

            channel(fs, dst);

            Files.delete(dst);

            // test foo.jar in jar/zipfs #8034802

            Path jpath = fs.getPath("/foo.jar");

            System.out.println("walking: " + jpath);

            try (FileSystem zzfs = FileSystems.newFileSystem(jpath)) {

                walk(zzfs.getPath("/"));

                // foojar:/srcInjarjar

                checkEqual(src, zzfs.getPath("/srcInjarjar"));

                dst = getPathWithParents(zzfs, tmpName);

                fchCopy(src, dst);

                checkEqual(src, dst);

                tmp = Paths.get(tmpName + "_Tmp");

                fchCopy(dst, tmp);   //  out

                checkEqual(src, tmp);

                Files.delete(tmp);

                channel(zzfs, dst);

                Files.delete(dst);

            }

        } finally {

            Files.deleteIfExists(tmpfsPath);

            Files.deleteIfExists(src);

        }

    }

    static void test2(FileSystem fs) throws Exception {

        Path fs1Path = getTempPath();

        Path fs2Path = getTempPath();

        Path fs3Path = getTempPath();

        // create a new filesystem, copy everything from fs

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

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

        FileSystem fs0 = newZipFileSystem(fs1Path, env);

        final FileSystem fs2 = newZipFileSystem(fs2Path, env);

        final FileSystem fs3 = newZipFileSystem(fs3Path, env);

        System.out.println("copy src: fs -> fs0...");

        z2zcopy(fs, fs0, "/", 0);   // copy fs -> fs1

        fs0.close();                // dump to file

        System.out.println("open fs0 as fs1");

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

        final FileSystem fs1 = newZipFileSystem(fs1Path, env);

        System.out.println("listing...");

        final ArrayList<String> files = new ArrayList<>();

        final ArrayList<String> dirs = new ArrayList<>();

        list(fs1.getPath("/"), files, dirs);

        Thread t0 = new Thread(new Runnable() {

            public void run() {

                List<String> list = new ArrayList<>(dirs);

                Collections.shuffle(list);

                for (String path : list) {

                    try {

                        z2zcopy(fs1, fs2, path, 0);

                    } catch (Exception x) {

                        x.printStackTrace();

                    }

                }

            }

        });

        Thread t1 = new Thread(new Runnable() {

            public void run() {

                List<String> list = new ArrayList<>(dirs);

                Collections.shuffle(list);

                for (String path : list) {

                    try {

                        z2zcopy(fs1, fs2, path, 1);

                    } catch (Exception x) {

                        x.printStackTrace();

                    }

                }

            }

        });

        Thread t2 = new Thread(new Runnable() {

            public void run() {

                List<String> list = new ArrayList<>(dirs);

                Collections.shuffle(list);

                for (String path : list) {

                    try {

                        z2zcopy(fs1, fs2, path, 2);

                    } catch (Exception x) {

                        x.printStackTrace();

                    }

                }

            }

        });

        Thread t3 = new Thread(new Runnable() {

            public void run() {

                List<String> list = new ArrayList<>(files);

                Collections.shuffle(list);

                while (!list.isEmpty()) {

                    Iterator<String> itr = list.iterator();

                    while (itr.hasNext()) {

                        String path = itr.next();

                        try {

                            if (Files.exists(fs2.getPath(path))) {

                                z2zmove(fs2, fs3, path);

                                itr.remove();

                            }

                        } catch (FileAlreadyExistsException x){

                            itr.remove();

                        } catch (Exception x) {

                            x.printStackTrace();

                        }

                    }

                }

            }

        });

        System.out.println("copying/removing...");

        t0.start(); t1.start(); t2.start(); t3.start();

        t0.join(); t1.join(); t2.join(); t3.join();

        System.out.println("closing: fs1, fs2");

        fs1.close();

        fs2.close();

        int failed = 0;

        System.out.println("checkEqual: fs vs fs3");

        for (String path : files) {

            try {

                checkEqual(fs.getPath(path), fs3.getPath(path));

            } catch (IOException x) {

                //x.printStackTrace();

                failed++;

            }

        }

        System.out.println("closing: fs3");

        fs3.close();

        System.out.println("opening: fs3 as fs4");

        FileSystem fs4 = newZipFileSystem(fs3Path, env);

        ArrayList<String> files2 = new ArrayList<>();

        ArrayList<String> dirs2 = new ArrayList<>();

        list(fs4.getPath("/"), files2, dirs2);

        System.out.println("checkEqual: fs vs fs4");

        for (String path : files2) {

            checkEqual(fs.getPath(path), fs4.getPath(path));

        }

        System.out.println("walking: fs4");

        walk(fs4.getPath("/"));

        System.out.println("closing: fs4");

        fs4.close();

        System.out.printf("failed=%d%n", failed);

        Files.delete(fs1Path);

        Files.delete(fs2Path);

        Files.delete(fs3Path);

    }

    static final int METHOD_STORED     = 0;

    static final int METHOD_DEFLATED   = 8;

    static Object[][] getEntries() {

        Object[][] entries = new Object[10 + rdm.nextInt(20)][3];

        // first entries shall test the corner case of 0 bytes of data

        entries[0][0] = "entries" + 0;

        entries[0][1] = METHOD_STORED;

        entries[0][2] = new byte[0];

        entries[1][0] = "entries" + 1;

        entries[1][1] = METHOD_DEFLATED;

        entries[1][2] = new byte[0];

        // the rest is random data

        for (int i = 2; i < entries.length; i++) {

            entries[i][0] = "entries" + i;

            entries[i][1] = rdm.nextInt(10) % 2 == 0 ?

                METHOD_STORED : METHOD_DEFLATED;

            entries[i][2] = new byte[rdm.nextInt(8192)];

            rdm.nextBytes((byte[])entries[i][2]);

        }

        return entries;

    }

    // check the content of read from zipfs is equal to the "bytes"

    private static void checkRead(Path path, byte[] expected) throws IOException {

        // fileAttribute

        CRC32 crc32 = new CRC32();

        crc32.update(expected);

        if (((Long)Files.getAttribute(path, "zip:crc")).intValue() !=

            (int)crc32.getValue()) {

            System.out.printf(" getAttribute.crc <%s> failed %x vs %x ...%n",

                              path.toString(),

                              ((Long)Files.getAttribute(path, "zip:crc")).intValue(),

                              (int)crc32.getValue());

            throw new RuntimeException("CHECK FAILED!");

        }

        if (((Long)Files.getAttribute(path, "zip:size")).intValue() != expected.length) {

            System.out.printf(" getAttribute.size <%s> failed %x vs %x ...%n",

                              path.toString(),

                              ((Long)Files.getAttribute(path, "zip:size")).intValue(),

                              expected.length);

            throw new RuntimeException("CHECK FAILED!");

        }

        //streams

        try (InputStream is = Files.newInputStream(path)) {

            if (!Arrays.equals(is.readAllBytes(), expected)) {

                System.out.printf(" newInputStream <%s> failed...%n", path.toString());

                throw new RuntimeException("CHECK FAILED!");

            }

        }

        // channels -- via sun.nio.ch.ChannelInputStream

        try (SeekableByteChannel sbc = Files.newByteChannel(path);

            InputStream is = Channels.newInputStream(sbc)) {

            // check all bytes match

            if (!Arrays.equals(is.readAllBytes(), expected)) {

                System.out.printf(" newByteChannel <%s> failed...%n", path.toString());

                throw new RuntimeException("CHECK FAILED!");

            }

            // Check if read position is at the end

            if (sbc.position() != expected.length) {

                System.out.printf("pos [%s]: size=%d, position=%d%n",

                                  path.toString(), expected.length, sbc.position());

                throw new RuntimeException("CHECK FAILED!");

            }

            // Check position(x) + read() at the random/specific pos/len

            byte[] buf = new byte[1024];

            ByteBuffer bb = ByteBuffer.wrap(buf);

            for (int i = 0; i < 10; i++) {

                int pos = 0;

                int len = 0;

                if (expected.length > 0) {

                    pos = rdm.nextInt((int) sbc.size());

                    len = rdm.nextInt(Math.min(buf.length, expected.length - pos));

                }

                // System.out.printf("  --> %d, %d%n", pos, len);

                bb.position(0).limit(len);    // bb.flip().limit(len);

                if (sbc.position(pos).position() != pos ||

                    sbc.read(bb) != len ||