/*

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

 */

/*

 * @test

 * @bug 8144355 8144062 8176709 8194070 8193802 8231093

 * @summary Test aliasing additions to ZipFileSystem for multi-release jar files

 * @library /lib/testlibrary/java/util/jar

 * @modules jdk.compiler

 *          jdk.jartool

 *          jdk.zipfs

 * @build Compiler JarBuilder CreateMultiReleaseTestJars

 * @run testng MultiReleaseJarTest

 */

import java.io.IOException;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.lang.Runtime.Version;

import java.net.URI;

import java.nio.file.*;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.atomic.AtomicInteger;

import org.testng.Assert;

import org.testng.annotations.*;

public class MultiReleaseJarTest {

    final private int MAJOR_VERSION = Runtime.version().feature();

    final private String userdir = System.getProperty("user.dir",".");

    final private CreateMultiReleaseTestJars creator =  new CreateMultiReleaseTestJars();

    final private Map<String,String> stringEnv = new HashMap<>();

    final private Map<String,Integer> integerEnv = new HashMap<>();

    final private Map<String,Version> versionEnv = new HashMap<>();

    final private String className = "version.Version";

    final private MethodType mt = MethodType.methodType(int.class);

    private String entryName;

    private URI uvuri;

    private URI mruri;

    private URI smruri;

    @BeforeClass

    public void initialize() throws Exception {

        creator.compileEntries();

        creator.buildUnversionedJar();

        creator.buildMultiReleaseJar();

        creator.buildShortMultiReleaseJar();

        String ssp = Paths.get(userdir, "unversioned.jar").toUri().toString();

        uvuri = new URI("jar", ssp , null);

        ssp = Paths.get(userdir, "multi-release.jar").toUri().toString();

        mruri = new URI("jar", ssp, null);

        ssp = Paths.get(userdir, "short-multi-release.jar").toUri().toString();

        smruri = new URI("jar", ssp, null);

        entryName = className.replace('.', '/') + ".class";

    }

    public void close() throws IOException {

        Files.delete(Paths.get(userdir, "unversioned.jar"));

        Files.delete(Paths.get(userdir, "multi-release.jar"));

        Files.delete(Paths.get(userdir, "short-multi-release.jar"));

    }

    @DataProvider(name="strings")

    public Object[][] createStrings() {

        return new Object[][]{

        };

    }

    @DataProvider(name="integers")

    public Object[][] createIntegers() {

        return new Object[][] {

        };

    }

    @DataProvider(name="versions")

    public Object[][] createVersions() {

        return new Object[][] {

        };

    }

    @DataProvider(name="invalidVersions")

    public Object[][] invalidVersions() {

        return new Object[][] {

        };

    }

    @Test

    public void testNewFileSystem() throws Exception {

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

        // no configuration, treat multi-release jar as unversioned

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

            Assert.assertTrue(readAndCompare(fs, 8));

        }

        // a configuration and jar file is multi-release

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

            Assert.assertTrue(readAndCompare(fs, MAJOR_VERSION));

        }

        // a configuration but jar file is unversioned

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

            Assert.assertTrue(readAndCompare(fs, 8));

        }

    }

    private boolean readAndCompare(FileSystem fs, int expected) throws IOException {

        Path path = fs.getPath("version/Version.java");

        String src = new String(Files.readAllBytes(path));

        return src.contains("return " + expected);

    }

    @Test(dataProvider="strings")

        runTest(stringEnv, expected);

    }

    @Test(dataProvider="integers")

        runTest(integerEnv, expected);

    }

    @Test(dataProvider="versions")

        runTest(versionEnv, expected);

    }

    @Test

    public void testShortJar() throws Throwable {

        runTest(smruri, integerEnv, MAJOR_VERSION);

        runTest(smruri, integerEnv, 8);

    }

    /**

     * Validate that an invalid value for the "releaseVersion" property throws

     * an {@code IllegalArgumentException}

     * @param env Zip FS map

     * @throws Throwable  Exception thrown for anything other than the expected

     * IllegalArgumentException

     */

    @Test(dataProvider="invalidVersions")

    public void testInvalidVersions(Map<String,?> env) throws Throwable {

        Assert.assertThrows(IllegalArgumentException.class, () ->

                FileSystems.newFileSystem(Path.of(userdir,

                        "multi-release.jar"), env));

    }

    // The following tests are for backwards compatibility to validate that

    // the original property still works

    @Test(dataProvider="strings")

        stringEnv.clear();

        runTest(stringEnv, expected);

    }

    @Test(dataProvider="integers")

        integerEnv.clear();

        runTest(integerEnv, expected);

    }

    @Test(dataProvider="versions")

        versionEnv.clear();

        runTest(versionEnv, expected);

    }

    private void runTest(Map<String,?> env, int expected) throws Throwable {

        runTest(mruri, env, expected);

    }

    private void runTest(URI uri, Map<String,?> env, int expected) throws Throwable {

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

            Path version = fs.getPath(entryName);

            byte [] bytes = Files.readAllBytes(version);

            Class<?> vcls = (new ByteArrayClassLoader(fs)).defineClass(className, bytes);

            MethodHandle mh = MethodHandles.lookup().findVirtual(vcls, "getVersion", mt);

            Assert.assertEquals((int)mh.invoke(vcls.getDeclaredConstructor().newInstance()), expected);

        }

    }

    @Test

    public void testIsMultiReleaseJar() throws Exception {

        // Re-examine commented out tests as part of JDK-8176843

        testCustomMultiReleaseValue("true", true);

        testCustomMultiReleaseValue("true\r\nOther: value", true);

        testCustomMultiReleaseValue("true\nOther: value", true);

        //testCustomMultiReleaseValue("true\rOther: value", true);

        testCustomMultiReleaseValue("false", false);

        testCustomMultiReleaseValue(" true", false);

        testCustomMultiReleaseValue("true ", false);

        //testCustomMultiReleaseValue("true\n ", false);

        //testCustomMultiReleaseValue("true\r ", false);

        //testCustomMultiReleaseValue("true\n true", false);

        //testCustomMultiReleaseValue("true\r\n true", false);

    }

    @Test

    public void testMultiReleaseJarWithNonVersionDir() throws Exception {

        String jfname = "multi-release-non-ver.jar";

        Path jfpath = Paths.get(jfname);

        URI uri = new URI("jar", jfpath.toUri().toString() , null);

        JarBuilder jb = new JarBuilder(jfname);

        jb.addAttribute("Multi-Release", "true");

        jb.build();

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

            Assert.assertTrue(true);

        }

        Files.delete(jfpath);

    }

    private static final AtomicInteger JAR_COUNT = new AtomicInteger(0);

    private void testCustomMultiReleaseValue(String value, boolean expected)

            throws Exception {

        String fileName = "custom-mr" + JAR_COUNT.incrementAndGet() + ".jar";

        creator.buildCustomMultiReleaseJar(fileName, value, Map.of(),

                /*addEntries*/true);

        Path filePath = Paths.get(userdir, fileName);

        String ssp = filePath.toUri().toString();

        URI customJar = new URI("jar", ssp , null);

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

            if (expected) {

                Assert.assertTrue(readAndCompare(fs, MAJOR_VERSION));

            } else {

                Assert.assertTrue(readAndCompare(fs, 8));

            }

        }

        Files.delete(filePath);

    }

    private static class ByteArrayClassLoader extends ClassLoader {

        final private FileSystem fs;

        ByteArrayClassLoader(FileSystem fs) {

            super(null);

            this.fs = fs;

        }

        @Override

        public Class<?> loadClass(String name) throws ClassNotFoundException {

            try {

                return super.loadClass(name);

            } catch (ClassNotFoundException x) {}

            Path cls = fs.getPath(name.replace('.', '/') + ".class");

            try {

                byte[] bytes = Files.readAllBytes(cls);

                return defineClass(name, bytes);

            } catch (IOException x) {

                throw new ClassNotFoundException(x.getMessage());

            }

        }

        public Class<?> defineClass(String name, byte[] bytes) throws ClassNotFoundException {

            if (bytes == null) throw new ClassNotFoundException("No bytes for " + name);

            return defineClass(name, bytes, 0, bytes.length);

        }

    }

}