/*
 * Copyright (c) 2015, 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 8132734
 * @summary Test the extended API and the aliasing additions in JarFile that
 *          support multi-release jar files
 * @library /lib/testlibrary/java/util/jar
 * @build Compiler JarBuilder CreateMultiReleaseTestJars
 * @run testng MultiReleaseJarIterators
 */

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.stream.Collectors;
import java.util.zip.ZipFile;

import static java.util.jar.JarFile.Release;
import static sun.misc.Version.jdkMajorVersion;  // fixme JEP 223 Version

import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;


public class MultiReleaseJarIterators {
    String userdir = System.getProperty("user.dir", ".");
    File unversioned = new File(userdir, "unversioned.jar");
    File multirelease = new File(userdir, "multi-release.jar");
    Map<String,JarEntry> uvEntries = new HashMap<>();
    Map<String,JarEntry> mrEntries = new HashMap<>();
    Map<String,JarEntry> baseEntries = new HashMap<>();
    Map<String,JarEntry> v9Entries = new HashMap<>();
    Map<String, JarEntry> v10Entries = new HashMap<>();

    @BeforeClass
    public void initialize() throws Exception {
        CreateMultiReleaseTestJars creator = new CreateMultiReleaseTestJars();
        creator.compileEntries();
        creator.buildUnversionedJar();
        creator.buildMultiReleaseJar();

        try (JarFile jf = new JarFile(multirelease)) {
            for (Enumeration<JarEntry> e = jf.entries(); e.hasMoreElements(); ) {
                JarEntry je = e.nextElement();
                String name = je.getName();
                mrEntries.put(name, je);
                if (name.startsWith("META-INF/versions/")) {
                    if (name.startsWith("META-INF/versions/9/")) {
                        v9Entries.put(name.substring(20), je);
                    } else if (name.startsWith("META-INF/versions/10/")) {
                        v10Entries.put(name.substring(21), je);
                    }
                } else {
                    baseEntries.put(name, je);
                }
            }
        }
        Assert.assertEquals(mrEntries.size(), 14);
        Assert.assertEquals(baseEntries.size(), 6);
        Assert.assertEquals(v9Entries.size(), 5);
        Assert.assertEquals(v10Entries.size(), 3);

        try (JarFile jf = new JarFile(unversioned)) {
            jf.entries().asIterator().forEachRemaining(je -> uvEntries.put(je.getName(), je));
        }
        Assert.assertEquals(uvEntries.size(), 6);
    }

    @AfterClass
    public void close() throws IOException {
        Files.delete(unversioned.toPath());
        Files.delete(multirelease.toPath());
    }

    @Test
    public void testMultiReleaseJar() throws IOException {
        try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ)) {
            testEnumeration(jf, mrEntries);
            testStream(jf, mrEntries);
        }

        try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ, Release.BASE)) {
            testEnumeration(jf, baseEntries);
            testStream(jf, baseEntries);
        }

        try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ, Release.VERSION_9)) {
            testEnumeration(jf, v9Entries);
            testStream(jf, v9Entries);
        }

        try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ, Release.RUNTIME)) {
            Map<String,JarEntry> expectedEntries;
            switch (jdkMajorVersion()) {
                case 9:
                    expectedEntries = v9Entries;
                    break;
                case 10:  // won't get here until JDK 10
                    expectedEntries = v10Entries;
                    break;
                default:
                    expectedEntries = baseEntries;
                    break;
            }

            testEnumeration(jf, expectedEntries);
            testStream(jf, expectedEntries);
        }
    }

    @Test
    public void testUnversionedJar() throws IOException {
        try (JarFile jf = new JarFile(unversioned, true, ZipFile.OPEN_READ)) {
            testEnumeration(jf, uvEntries);
            testStream(jf, uvEntries);
        }

        try (JarFile jf = new JarFile(unversioned, true, ZipFile.OPEN_READ, Release.BASE)) {
            testEnumeration(jf, uvEntries);
            testStream(jf, uvEntries);
        }

        try (JarFile jf = new JarFile(unversioned, true, ZipFile.OPEN_READ, Release.VERSION_9)) {
            testEnumeration(jf, uvEntries);
            testStream(jf, uvEntries);
        }

        try (JarFile jf = new JarFile(unversioned, true, ZipFile.OPEN_READ, Release.RUNTIME)) {
            testEnumeration(jf, uvEntries);
            testStream(jf, uvEntries);
        }
    }

    private void testEnumeration(JarFile jf, Map<String,JarEntry> expectedEntries) {
        Map<String, JarEntry> actualEntries = new HashMap<>();
        for (Enumeration<JarEntry> e = jf.entries(); e.hasMoreElements(); ) {
            JarEntry je = e.nextElement();
            actualEntries.put(je.getName(), je);
        }

        testEntries(jf, actualEntries, expectedEntries);
    }


    private void testStream(JarFile jf, Map<String,JarEntry> expectedEntries) {
        Map<String,JarEntry> actualEntries = jf.stream().collect(Collectors.toMap(je -> je.getName(), je -> je));

        testEntries(jf, actualEntries, expectedEntries);
    }

    private void testEntries(JarFile jf, Map<String,JarEntry> actualEntries, Map<String,JarEntry> expectedEntries) {
        /* For multi-release jar files constructed with a Release object,
         * actualEntries contain versionedEntries that are considered part of the
         * public API.  They have a 1-1 correspondence with baseEntries,
         * so entries that are not part of the public API won't be present,
         * i.e. those entries with a name that starts with version/PackagePrivate
         * in this particular jar file (multi-release.jar)
         */

        Map<String,JarEntry> entries;
        if (expectedEntries == mrEntries) {
            Assert.assertEquals(actualEntries.size(), mrEntries.size());
            entries = mrEntries;
        } else if (expectedEntries == uvEntries) {
            Assert.assertEquals(actualEntries.size(), uvEntries.size());
            entries = uvEntries;
        } else {
            Assert.assertEquals(actualEntries.size(), baseEntries.size());  // this is correct
            entries = baseEntries;
        }

        entries.keySet().forEach(name -> {
            JarEntry ee = expectedEntries.get(name);
            if (ee == null) ee = entries.get(name);
            JarEntry ae = actualEntries.get(name);
            try {
                compare(jf, ae, ee);
            } catch (IOException x) {
                throw new RuntimeException(x);
            }
        });
    }

    private void compare(JarFile jf, JarEntry actual, JarEntry expected) throws IOException {
        byte[] abytes;
        byte[] ebytes;

        try (InputStream is = jf.getInputStream(actual)) {
            abytes = is.readAllBytes();
        }

        try (InputStream is = jf.getInputStream(expected)) {
            ebytes = is.readAllBytes();
        }

        Assert.assertEquals(abytes, ebytes);
    }
}