/*
 * Copyright (c) 2025, 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 static jdk.internal.util.OperatingSystem.WINDOWS;
import static jdk.jpackage.test.HelloApp.configureAndExecute;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import jdk.jpackage.internal.util.TokenReplace;
import jdk.jpackage.test.Annotations.ParameterSupplier;
import jdk.jpackage.test.Annotations.Test;
import jdk.jpackage.test.Executor;
import jdk.jpackage.test.JPackageCommand;
import jdk.jpackage.test.JPackageCommand.Macro;
import jdk.jpackage.test.TKit;

/*
 * @test
 * @summary Tests environment variables substitution by jpackage launcher
 * @bug 8341641
 * @library /test/jdk/tools/jpackage/helpers
 * @build jdk.jpackage.test.*
 * @build AppLauncherSubstTest
 * @run main/othervm -Xmx512m jdk.jpackage.test.Main
 *  --jpt-run=AppLauncherSubstTest
 */
public class AppLauncherSubstTest {

    record TestSpec(String str, String expectedStr, Map<String, String> env) {

        static class Builder {

            Builder str(String v) {
                str = v;
                return this;
            }

            Builder expect(String v) {
                expectedStr = v;
                return this;
            }

            Builder var(String name, String value) {
                env.put(name, value);
                return this;
            }

            TestSpec create() {
                return new TestSpec(str, Optional.ofNullable(expectedStr).orElse(str), env);
            }

            private String str;
            private String expectedStr;
            private Map<String, String> env = new LinkedHashMap<>();
        }

        public TestSpec {
            Objects.requireNonNull(str);
            Objects.requireNonNull(expectedStr);
            Objects.requireNonNull(env);
            env.entrySet().forEach(Objects::requireNonNull);
        }

        public String resolveExpectedStr(JPackageCommand cmd) {
            return MACROS.applyTo(expectedStr, token -> {
                // @@APPDIR@@ -> APPDIR
                final var macro = token.substring(2, token.length() - 2);
                return Path.of(cmd.macroValue(Macro.valueOf(macro))).toAbsolutePath();
            });
        }

        @Override
        public String toString() {
            final var sb = new StringBuilder();
            sb.append("str=").append(str);
            sb.append(", expect=").append(expectedStr);
            if (!env.isEmpty()) {
                sb.append(", env=").append(env);
            }
            return sb.toString();
        }

        private final static TokenReplace MACROS = new TokenReplace(Stream.of(Macro.values()).map(macro -> {
            return String.format("@@%s@@", macro);
        }).toArray(String[]::new));
    }

    @Test
    @ParameterSupplier
    @ParameterSupplier(value = "testCaseSensitive", ifNotOS = WINDOWS)
    @ParameterSupplier(value = "testCaseInsensitive", ifOS = WINDOWS)
    public static void test(TestSpec spec) throws IOException {
        final var cmd = JPackageCommand.helloAppImage(TEST_APP_JAVA + "*Hello")
                .ignoreFakeRuntime()
                .setArgumentValue("--java-options", "-D" + TEST_PROP + "=");

        cmd.execute();

        // Manually edit main launcher config file. Don't do it directly because
        // jpackage doesn't pass the value of `--java-options` option as-is into the config file.
        final var cfgFile = cmd.appLauncherCfgPath(null);
        TKit.createTextFile(cfgFile, Files.readAllLines(cfgFile).stream().map(line -> {
            return TEST_PROP_REGEXP.matcher(line).replaceFirst(Matcher.quoteReplacement(spec.str()));
        }));

        final var launcherExec = new Executor()
                .saveOutput()
                .dumpOutput()
                .setExecutable(cmd.appLauncherPath().toAbsolutePath())
                .addArguments("--print-sys-prop=" + TEST_PROP);

        spec.env().forEach(launcherExec::setEnvVar);

        final var resolvedExpectedStr = spec.resolveExpectedStr(cmd);
        final var actualStr = configureAndExecute(0, launcherExec).getFirstLineOfOutput().substring((TEST_PROP + "=").length());

        if (TKit.isWindows() && !resolvedExpectedStr.equals(spec.expectedStr())) {
            TKit.assertEquals(resolvedExpectedStr.toLowerCase(), actualStr.toLowerCase(), "Check the property value is as expected [lowercase]");
        } else {
            TKit.assertEquals(resolvedExpectedStr, actualStr, "Check the property value is as expected");
        }
    }

    public static Collection<Object[]> test() {
        return Stream.of(
                testSpec(""),
                testSpec("$ONE ${TWO} ${ONE} $TWO ONE TWO").expect("one two one two ONE TWO").var("ONE", "one").var("TWO", "two"),
                testSpec("\\$FOO\\\\$FOO\\${FOO}\\\\${FOO}").expect("$FOO\\BAR${FOO}\\BAR").var("FOO", "BAR"),
                testSpec("$FOO-$BAR").expect("$FOO-").var("BAR", ""),
                testSpec("${BINDIR}${APPDIR}${ROOTDIR}").expect("@@BINDIR@@@@APPDIR@@@@ROOTDIR@@").var("BINDIR", "a").var("APPDIR", "b").var("ROOTDIR", "c"),
                testSpec("$BINDIR$APPDIR$ROOTDIR").expect("@@BINDIR@@@@APPDIR@@@@ROOTDIR@@"),
                testSpec("$BINDIR2$APPDIR2$ROOTDIR2").expect("$BINDIR2$APPDIR2$ROOTDIR2")
        ).map(TestSpec.Builder::create).map(v -> {
            return new Object[] {v};
        }).toList();
    }

    public static Collection<Object[]> testCaseSensitive() {
        final List<TestSpec> testCases = new ArrayList<>();
        for (final var macro : Macro.values()) {
            testCases.addAll(createTestCases(macro, true));
        }

        testCases.addAll(Stream.of(
                testSpec("$ALPHA $alpha").expect("A a").var("ALPHA", "A").var("alpha", "a"),
                testSpec("$ALPHA $alpha").expect("$ALPHA a").var("alpha", "a"),
                testSpec("$ALPHA $alpha").expect("A $alpha").var("ALPHA", "A")
        ).map(TestSpec.Builder::create).toList());

        return testCases.stream().map(v -> {
            return new Object[] {v};
        }).toList();
    }

    public static Collection<Object[]> testCaseInsensitive() {
        final List<TestSpec> testCases = new ArrayList<>();
        for (final var macro : Macro.values()) {
            testCases.addAll(createTestCases(macro, false));
        }

        testCases.addAll(Stream.of(
                testSpec("$ALPHA $alpha").expect("A A").var("AlphA", "A"),
                testSpec("$ALPHA $alpha").expect("a a").var("alpha", "a"),
                testSpec("$ALPHA $alpha").expect("A A").var("ALPHA", "A")
        ).map(TestSpec.Builder::create).toList());

        return testCases.stream().map(v -> {
            return new Object[] {v};
        }).toList();
    }

    private static List<TestSpec> createTestCases(Macro macro, boolean caseSensitive) {
        final var name = macro.name();
        final var name2 = name.transform(str -> {
            final var chars = name.toCharArray();
            for (int i = 0; i < chars.length; i += 2) {
                chars[i] = Character.toLowerCase(chars[i]);
            }
            return new String(chars);
        });

        if (name.equals(name2)) {
            throw new UnsupportedOperationException();
        }

        final var testSpec = testSpec(String.format("${%s}${%s}", name, name2)).var(name, "A").var(name2, "[foo]");
        if (caseSensitive) {
            testSpec.expect(String.format("@@%s@@[foo]", name, name2));
        } else {
            testSpec.expect(String.format("@@%s@@@@%s@@", name, name));
        }

        final var testSpec2 = testSpec(String.format("${%s}${%s}", name, name2)).var(name, "A");
        if (caseSensitive) {
            testSpec2.expect(String.format("@@%s@@${%s}", name, name2));
        } else {
            testSpec2.expect(String.format("@@%s@@@@%s@@", name, name));
        }

        final var testSpec3 = testSpec(String.format("${%s}${%s}", name, name2));
        if (caseSensitive) {
            testSpec3.expect(String.format("@@%s@@${%s}", name, name2));
        } else {
            testSpec3.expect(String.format("@@%s@@@@%s@@", name, name));
        }

        return Stream.of(testSpec, testSpec2).map(TestSpec.Builder::create).toList();
    }

    private static TestSpec.Builder testSpec(String str) {
        return new TestSpec.Builder().str(str);
    }

    private static final Path TEST_APP_JAVA = TKit.TEST_SRC_ROOT.resolve("apps/PrintEnv.java");

    private static final String TEST_PROP = "jdk.jpackage.test.Property";
    private static final Pattern TEST_PROP_REGEXP = Pattern.compile("(?<=" + Pattern.quote(TEST_PROP) + "=).*");
}