/*

 * Copyright (c) 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

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

 */

package jdk.jpackage.internal;

import java.io.*;

import java.nio.charset.StandardCharsets;

import java.nio.file.Files;

import java.nio.file.Path;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import jdk.jpackage.internal.resources.ResourceLocator;

import static org.hamcrest.CoreMatchers.is;

import static org.hamcrest.CoreMatchers.not;

import static org.junit.Assert.*;

import org.junit.Rule;

import org.junit.Test;

import org.junit.rules.TemporaryFolder;

public class OverridableResourceTest {

    @Rule

    public final TemporaryFolder tempFolder = new TemporaryFolder();

    @Test

    public void testDefault() throws IOException {

        byte[] actualBytes = saveToFile(new OverridableResource(DEFAULT_NAME));

        try (InputStream is = ResourceLocator.class.getResourceAsStream(

                DEFAULT_NAME)) {

            assertArrayEquals(is.readAllBytes(), actualBytes);

        }

    }

    @Test

    public void testDefaultWithSubstitution() throws IOException {

        OverridableResource resource = new OverridableResource(DEFAULT_NAME);

        List<String> linesBeforeSubstitution = convertToStringList(saveToFile(

                resource));

        if (SUBSTITUTION_DATA.size() != 1) {

            // Test setup issue

            throw new IllegalArgumentException(

                    "Substitution map should contain only a single entry");

        }

        resource.setSubstitutionData(SUBSTITUTION_DATA);

        List<String> linesAfterSubstitution = convertToStringList(saveToFile(

                resource));

        assertEquals(linesBeforeSubstitution.size(), linesAfterSubstitution.size());

        Iterator<String> beforeIt = linesBeforeSubstitution.iterator();

        Iterator<String> afterIt = linesAfterSubstitution.iterator();

        var substitutionEntry = SUBSTITUTION_DATA.entrySet().iterator().next();

        boolean linesMismatch = false;

        while (beforeIt.hasNext()) {

            String beforeStr = beforeIt.next();

            String afterStr = afterIt.next();

            if (beforeStr.equals(afterStr)) {

                assertFalse(beforeStr.contains(substitutionEntry.getKey()));

            } else {

                linesMismatch = true;

                assertTrue(beforeStr.contains(substitutionEntry.getKey()));

                assertTrue(afterStr.contains(substitutionEntry.getValue()));

                assertFalse(afterStr.contains(substitutionEntry.getKey()));

            }

        }

        assertTrue(linesMismatch);

    }

    @Test

    public void testCustom() throws IOException {

        testCustom(DEFAULT_NAME);

    }

    @Test

    public void testCustomNoDefault() throws IOException {

        testCustom(null);

    }

    private void testCustom(String defaultName) throws IOException {

        List<String> expectedResourceData = List.of("A", "B", "C");

        Path customFile = createCustomFile("foo", expectedResourceData);

        List<String> actualResourceData = convertToStringList(saveToFile(

                new OverridableResource(defaultName)

                        .setPublicName(customFile.getFileName())

                        .setResourceDir(customFile.getParent())));

        assertArrayEquals(expectedResourceData.toArray(String[]::new),

                actualResourceData.toArray(String[]::new));

    }

    @Test

    public void testCustomtWithSubstitution() throws IOException {

        testCustomtWithSubstitution(DEFAULT_NAME);

    }

    @Test

    public void testCustomtWithSubstitutionNoDefault() throws IOException {

        testCustomtWithSubstitution(null);

    }

    private void testCustomtWithSubstitution(String defaultName) throws IOException {

        final List<String> resourceData = List.of("A", "[BB]", "C", "Foo",

                "GoodbyeHello");

        final Path customFile = createCustomFile("foo", resourceData);

        final Map<String, String> substitutionData = new HashMap(Map.of("B",

                "Bar", "Foo", "B"));

        substitutionData.put("Hello", null);

        final List<String> expectedResourceData = List.of("A", "[BarBar]", "C",

                "B", "Goodbye");

        final List<String> actualResourceData = convertToStringList(saveToFile(

                new OverridableResource(defaultName)

                        .setPublicName(customFile.getFileName())

                        .setSubstitutionData(substitutionData)

                        .setResourceDir(customFile.getParent())));

        assertArrayEquals(expectedResourceData.toArray(String[]::new),

                actualResourceData.toArray(String[]::new));

        // Don't call setPublicName()

        final Path dstFile = tempFolder.newFolder().toPath().resolve(customFile.getFileName());

        new OverridableResource(defaultName)

                .setSubstitutionData(substitutionData)

                .setResourceDir(customFile.getParent())

                .saveToFile(dstFile);

        assertArrayEquals(expectedResourceData.toArray(String[]::new),

                convertToStringList(Files.readAllBytes(dstFile)).toArray(

                        String[]::new));

        // Verify setSubstitutionData() stores a copy of passed in data

        Map<String, String> substitutionData2 = new HashMap(substitutionData);

        var resource = new OverridableResource(defaultName)

                .setResourceDir(customFile.getParent());

        resource.setSubstitutionData(substitutionData2);

        substitutionData2.clear();

        Files.delete(dstFile);

        resource.saveToFile(dstFile);

        assertArrayEquals(expectedResourceData.toArray(String[]::new),

                convertToStringList(Files.readAllBytes(dstFile)).toArray(

                        String[]::new));

    }

    @Test

    public void testNoDefault() throws IOException {

        Path dstFolder = tempFolder.newFolder().toPath();

        Path dstFile = dstFolder.resolve(Path.of("foo", "bar"));

        new OverridableResource(null).saveToFile(dstFile);

        assertFalse(dstFile.toFile().exists());

    }

    private final static String DEFAULT_NAME;

    private final static Map<String, String> SUBSTITUTION_DATA;

    static {

        if (Platform.isWindows()) {

            DEFAULT_NAME = "WinLauncher.template";

            SUBSTITUTION_DATA = Map.of("COMPANY_NAME", "Foo9090345");

        } else if (Platform.isLinux()) {

            DEFAULT_NAME = "template.control";

            SUBSTITUTION_DATA = Map.of("APPLICATION_PACKAGE", "Package1967");

        } else if (Platform.isMac()) {

            DEFAULT_NAME = "Info-lite.plist.template";

            SUBSTITUTION_DATA = Map.of("DEPLOY_BUNDLE_IDENTIFIER", "12345");

        } else {

            throw Platform.throwUnknownPlatformError();

        }

    }

    private byte[] saveToFile(OverridableResource resource) throws IOException {

        Path dstFile = tempFolder.newFile().toPath();

        resource.saveToFile(dstFile);

        assertThat(0, is(not(dstFile.toFile().length())));

        return Files.readAllBytes(dstFile);

    }

    private Path createCustomFile(String publicName, List<String> data) throws

            IOException {

        Path resourceFolder = tempFolder.newFolder().toPath();

        Path customFile = resourceFolder.resolve(publicName);

        Files.write(customFile, data);

        return customFile;

    }

    private static List<String> convertToStringList(byte[] data) {

        return List.of(new String(data, StandardCharsets.UTF_8).split("\\R"));

    }

}