/*

 * Copyright (c) 2015, 2018, 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.packager.internal.builders.mac;

import jdk.packager.internal.BundlerParamInfo;

import jdk.packager.internal.IOUtils;

import jdk.packager.internal.Log;

import jdk.packager.internal.Platform;

import jdk.packager.internal.RelativeFileSet;

import jdk.packager.internal.StandardBundlerParam;

import jdk.packager.internal.Arguments;

import jdk.packager.internal.resources.mac.MacResources;

import jdk.packager.internal.builders.AbstractAppImageBuilder;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.UncheckedIOException;

import java.io.Writer;

import java.math.BigInteger;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.attribute.PosixFilePermission;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Optional;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.concurrent.atomic.AtomicReference;

import java.util.function.Consumer;

import static jdk.packager.internal.StandardBundlerParam.*;

import static jdk.packager.internal.mac.MacBaseInstallerBundler.*;

import static jdk.packager.internal.mac.MacAppBundler.*;

public class MacAppImageBuilder extends AbstractAppImageBuilder {

    private static final ResourceBundle I18N =

            ResourceBundle.getBundle("jdk.packager.internal.resources.builders.mac.MacAppImageBuilder");

    private static final String EXECUTABLE_NAME = "JavaAppLauncher";

    private static final String LIBRARY_NAME = "libpackager.dylib";

    private static final String TEMPLATE_BUNDLE_ICON = "GenericApp.icns";

    private static final String OS_TYPE_CODE = "APPL";

    private static final String TEMPLATE_INFO_PLIST_LITE = "Info-lite.plist.template";

    private static final String TEMPLATE_RUNTIME_INFO_PLIST = "Runtime-Info.plist.template";

    private final Path root;

    private final Path contentsDir;

    private final Path javaDir;

    private final Path resourcesDir;

    private final Path macOSDir;

    private final Path runtimeDir;

    private final Path runtimeRoot;

    private final Path mdir;

    private final Map<String, ? super Object> params;

    private static List<String> keyChains;

    private static Map<String, String> getMacCategories() {

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

        map.put("Business", "public.app-category.business");

        map.put("Developer Tools", "public.app-category.developer-tools");

        map.put("Education", "public.app-category.education");

        map.put("Entertainment", "public.app-category.entertainment");

        map.put("Finance", "public.app-category.finance");

        map.put("Games", "public.app-category.games");

        map.put("Graphics & Design", "public.app-category.graphics-design");

        map.put("Healthcare & Fitness", "public.app-category.healthcare-fitness");

        map.put("Lifestyle", "public.app-category.lifestyle");

        map.put("Medical", "public.app-category.medical");

        map.put("Music", "public.app-category.music");

        map.put("News", "public.app-category.news");

        map.put("Photography", "public.app-category.photography");

        map.put("Productivity", "public.app-category.productivity");

        map.put("Reference", "public.app-category.reference");

        map.put("Social Networking", "public.app-category.social-networking");

        map.put("Sports", "public.app-category.sports");

        map.put("Travel", "public.app-category.travel");

        map.put("Utilities", "public.app-category.utilities");

        map.put("Video", "public.app-category.video");

        map.put("Weather", "public.app-category.weather");

        map.put("Action Games", "public.app-category.action-games");

        map.put("Adventure Games", "public.app-category.adventure-games");

        map.put("Arcade Games", "public.app-category.arcade-games");

        map.put("Board Games", "public.app-category.board-games");

        map.put("Card Games", "public.app-category.card-games");

        map.put("Casino Games", "public.app-category.casino-games");

        map.put("Dice Games", "public.app-category.dice-games");

        map.put("Educational Games", "public.app-category.educational-games");

        map.put("Family Games", "public.app-category.family-games");

        map.put("Kids Games", "public.app-category.kids-games");

        map.put("Music Games", "public.app-category.music-games");

        map.put("Puzzle Games", "public.app-category.puzzle-games");

        map.put("Racing Games", "public.app-category.racing-games");

        map.put("Role Playing Games", "public.app-category.role-playing-games");

        map.put("Simulation Games", "public.app-category.simulation-games");

        map.put("Sports Games", "public.app-category.sports-games");

        map.put("Strategy Games", "public.app-category.strategy-games");

        map.put("Trivia Games", "public.app-category.trivia-games");

        map.put("Word Games", "public.app-category.word-games");

        return map;

    }

    public static final BundlerParamInfo<Boolean> MAC_CONFIGURE_LAUNCHER_IN_PLIST =

            new StandardBundlerParam<>(

                    I18N.getString("param.configure-launcher-in-plist"),

                    I18N.getString("param.configure-launcher-in-plist.description"),

                    "mac.configure-launcher-in-plist",

                    Boolean.class,

                    params -> Boolean.FALSE,

                    (s, p) -> Boolean.valueOf(s));

    public static final BundlerParamInfo<String> MAC_CATEGORY =

            new StandardBundlerParam<>(

                    I18N.getString("param.category-name"),

                    I18N.getString("param.category-name.description"),

                    "mac.category",

                    String.class,

                    CATEGORY::fetchFrom,

                    (s, p) -> s

            );

    public static final BundlerParamInfo<String> MAC_CF_BUNDLE_NAME =

            new StandardBundlerParam<>(

                    I18N.getString("param.cfbundle-name.name"),

                    I18N.getString("param.cfbundle-name.description"),

                    "mac.CFBundleName",

                    String.class,

                    params -> null,

                    (s, p) -> s);

    public static final BundlerParamInfo<String> MAC_CF_BUNDLE_IDENTIFIER =

            new StandardBundlerParam<>(

                    I18N.getString("param.cfbundle-identifier.name"),

                    I18N.getString("param.cfbundle-identifier.description"),

                    Arguments.CLIOptions.MAC_BUNDLE_IDENTIFIER.getId(),

                    String.class,

                    IDENTIFIER::fetchFrom,

                    (s, p) -> s);

    public static final BundlerParamInfo<String> MAC_CF_BUNDLE_VERSION =

            new StandardBundlerParam<>(

                    I18N.getString("param.cfbundle-version.name"),

                    I18N.getString("param.cfbundle-version.description"),

                    "mac.CFBundleVersion",

                    String.class,

                    p -> {

                        String s = VERSION.fetchFrom(p);

                        if (validCFBundleVersion(s)) {

                            return s;

                        } else {

                            return "100";

                        }

                    },

                    (s, p) -> s);

    public static final BundlerParamInfo<File> CONFIG_ROOT = new StandardBundlerParam<>(

            I18N.getString("param.config-root.name"),

            I18N.getString("param.config-root.description"),

            "configRoot",

            File.class,

            params -> {

                File configRoot = new File(BUILD_ROOT.fetchFrom(params), "macosx");

                configRoot.mkdirs();

                return configRoot;

            },

            (s, p) -> new File(s));

    public static final BundlerParamInfo<String> DEFAULT_ICNS_ICON = new StandardBundlerParam<>(

            I18N.getString("param.default-icon-icns"),

            I18N.getString("param.default-icon-icns.description"),

            ".mac.default.icns",

            String.class,

            params -> TEMPLATE_BUNDLE_ICON,

            (s, p) -> s);

    public static final BundlerParamInfo<File> ICON_ICNS = new StandardBundlerParam<>(

            I18N.getString("param.icon-icns.name"),

            I18N.getString("param.icon-icns.description"),

            "icon.icns",

            File.class,

            params -> {

                File f = ICON.fetchFrom(params);

                if (f != null && !f.getName().toLowerCase().endsWith(".icns")) {

                    Log.info(MessageFormat.format(I18N.getString("message.icon-not-icns"), f));

                    return null;

                }

                return f;

            },

            (s, p) -> new File(s));

    public static final StandardBundlerParam<Boolean> SIGN_BUNDLE  =

    new StandardBundlerParam<>(

            I18N.getString("param.sign-bundle.name"),

            I18N.getString("param.sign-bundle.description"),

            Arguments.CLIOptions.MAC_SIGN.getId(),

            Boolean.class,

            params -> false,

            // valueOf(null) is false, and we actually do want null in some cases

            (s, p) -> (s == null || "null".equalsIgnoreCase(s))? null : Boolean.valueOf(s)

        );

    public MacAppImageBuilder(Map<String, Object> config, Path imageOutDir) throws IOException {

        super(config, imageOutDir.resolve(APP_NAME.fetchFrom(config) + ".app/Contents/PlugIns/Java.runtime/Contents/Home"));

        Objects.requireNonNull(imageOutDir);

        this.params = config;

        this.root = imageOutDir.resolve(APP_NAME.fetchFrom(params) + ".app");

        this.contentsDir = root.resolve("Contents");

        this.javaDir = contentsDir.resolve("Java");

        this.resourcesDir = contentsDir.resolve("Resources");

        this.macOSDir = contentsDir.resolve("MacOS");

        this.runtimeDir = contentsDir.resolve("PlugIns/Java.runtime");

        this.runtimeRoot = runtimeDir.resolve("Contents/Home");

        this.mdir = runtimeRoot.resolve("lib");

        Files.createDirectories(javaDir);

        Files.createDirectories(resourcesDir);

        Files.createDirectories(macOSDir);

        Files.createDirectories(runtimeDir);

    }

    public MacAppImageBuilder(Map<String, Object> config, String jreName,

            Path imageOutDir) throws IOException {

        super(null, imageOutDir.resolve(jreName + "/Contents/Home"));

        Objects.requireNonNull(imageOutDir);

        this.params = config;

        this.root = imageOutDir.resolve(jreName );

        this.contentsDir = root.resolve("Contents");

        this.javaDir = null;

        this.resourcesDir = null;

        this.macOSDir = null;

        this.runtimeDir = this.root;

        this.runtimeRoot = runtimeDir.resolve("Contents/Home");

        this.mdir = runtimeRoot.resolve("lib");

        Files.createDirectories(runtimeDir);

    }

    private void writeEntry(InputStream in, Path dstFile) throws IOException {

        Files.createDirectories(dstFile.getParent());

        Files.copy(in, dstFile);

    }

    // chmod ugo+x file

    private void setExecutable(Path file) {

        try {

            Set<PosixFilePermission> perms = Files.getPosixFilePermissions(file);

            perms.add(PosixFilePermission.OWNER_EXECUTE);

            perms.add(PosixFilePermission.GROUP_EXECUTE);

            perms.add(PosixFilePermission.OTHERS_EXECUTE);

            Files.setPosixFilePermissions(file, perms);

        } catch (IOException ioe) {

            throw new UncheckedIOException(ioe);

        }

    }

    private static void createUtf8File(File file, String content) throws IOException {

        try (OutputStream fout = new FileOutputStream(file);

             Writer output = new OutputStreamWriter(fout, "UTF-8")) {

            output.write(content);

        }

    }

    @Override

    protected String getCacheLocation(Map<String, ? super Object> params) {

        return "$CACHEDIR/";

    }

    public static boolean validCFBundleVersion(String v) {

        // CFBundleVersion (String - iOS, OS X) specifies the build version

        // number of the bundle, which identifies an iteration (released or

        // unreleased) of the bundle. The build version number should be a

        // string comprised of three non-negative, period-separated integers

        // with the first integer being greater than zero. The string should

        // only contain numeric (0-9) and period (.) characters. Leading zeros

        // are truncated from each integer and will be ignored (that is,

        // 1.02.3 is equivalent to 1.2.3). This key is not localizable.

        if (v == null) {

            return false;

        }

        String p[] = v.split("\\.");

        if (p.length > 3 || p.length < 1) {

            Log.verbose(I18N.getString("message.version-string-too-many-components"));

            return false;

        }

        try {

            BigInteger n = new BigInteger(p[0]);

            if (BigInteger.ONE.compareTo(n) > 0) {

                Log.verbose(I18N.getString("message.version-string-first-number-not-zero"));

                return false;

            }

            if (p.length > 1) {

                n = new BigInteger(p[1]);

                if (BigInteger.ZERO.compareTo(n) > 0) {

                    Log.verbose(I18N.getString("message.version-string-no-negative-numbers"));

                    return false;

                }

            }

            if (p.length > 2) {

                n = new BigInteger(p[2]);

                if (BigInteger.ZERO.compareTo(n) > 0) {

                    Log.verbose(I18N.getString("message.version-string-no-negative-numbers"));

                    return false;

                }

            }

        } catch (NumberFormatException ne) {

            Log.verbose(I18N.getString("message.version-string-numbers-only"));

            Log.verbose(ne);

            return false;

        }

        return true;

    }

    @Override

    public InputStream getResourceAsStream(String name) {

        return MacResources.class.getResourceAsStream(name);

    }

    @Override

    public void prepareApplicationFiles() throws IOException {

        File f;

        // Generate PkgInfo

        File pkgInfoFile = new File(contentsDir.toFile(), "PkgInfo");

        pkgInfoFile.createNewFile();

        writePkgInfo(pkgInfoFile);

        Path executable = macOSDir.resolve(getLauncherName(params));

        try (InputStream is_launcher = getResourceAsStream("papplauncher");

             InputStream is_lib = getResourceAsStream(LIBRARY_NAME)) {

            // Copy executable and library to MacOS folder

            writeEntry(is_launcher, executable);

            writeEntry(is_lib, macOSDir.resolve(LIBRARY_NAME));

        }

        executable.toFile().setExecutable(true, false);

        // generate launcher config

        writeCfgFile(params, new File(root.toFile(), getLauncherCfgName(params)),

                "$APPDIR/PlugIns/Java.runtime");

        // Copy class path entries to Java folder

        copyClassPathEntries(javaDir);

        /*********** Take care of "config" files *******/

        File icon = ICON_ICNS.fetchFrom(params);

        InputStream in = locateResource("package/macosx/" + APP_NAME.fetchFrom(params) + ".icns",

                "icon",

                DEFAULT_ICNS_ICON.fetchFrom(params),

                icon,

                VERBOSE.fetchFrom(params),

                DROP_IN_RESOURCES_ROOT.fetchFrom(params));

        Files.copy(in, resourcesDir.resolve(APP_NAME.fetchFrom(params) + ".icns"));

        // copy file association icons

        for (Map<String, ? super Object> fa : FILE_ASSOCIATIONS.fetchFrom(params)) {

            f = FA_ICON.fetchFrom(fa);

            if (f != null && f.exists()) {

                try (InputStream in2 = new FileInputStream(f)) {

                    Files.copy(in2, resourcesDir.resolve(f.getName()));

                }

            }

        }

        copyRuntimeFiles();

        sign();

    }

    @Override

    public void prepareServerJreFiles() throws IOException {

        copyRuntimeFiles();

        sign();

    }

    private void copyRuntimeFiles() throws IOException {

        // Generate Info.plist

        writeInfoPlist(contentsDir.resolve("Info.plist").toFile());

        // generate java runtime info.plist

        writeRuntimeInfoPlist(runtimeDir.resolve("Contents/Info.plist").toFile());

        // copy library

        Path runtimeMacOSDir = Files.createDirectories(

                runtimeDir.resolve("Contents/MacOS"));

        Files.copy(runtimeRoot.resolve("lib/jli/libjli.dylib"),

                runtimeMacOSDir.resolve("libjli.dylib"));

    }

    private void sign() throws IOException {

        if (Optional.ofNullable(SIGN_BUNDLE.fetchFrom(params)).orElse(Boolean.TRUE)) {

            try {

                addNewKeychain(params);

            } catch (InterruptedException e) {

                Log.error(e.getMessage());

            }

            String signingIdentity = DEVELOPER_ID_APP_SIGNING_KEY.fetchFrom(params);

            if (signingIdentity != null) {

                signAppBundle(params, root, signingIdentity,

                        BUNDLE_ID_SIGNING_PREFIX.fetchFrom(params), null, null);

            }

            restoreKeychainList(params);

        }

    }

    private String getLauncherName(Map<String, ? super Object> params) {

        if (APP_NAME.fetchFrom(params) != null) {

            return APP_NAME.fetchFrom(params);

        } else {

            return MAIN_CLASS.fetchFrom(params);

        }

    }

    public static String getLauncherCfgName(Map<String, ? super Object> p) {

        return "Contents/Java/" + APP_NAME.fetchFrom(p) + ".cfg";

    }

    private void copyClassPathEntries(Path javaDirectory) throws IOException {

        List<RelativeFileSet> resourcesList = APP_RESOURCES_LIST.fetchFrom(params);

        if (resourcesList == null) {

            throw new RuntimeException(I18N.getString("message.null-classpath"));

        }

        for (RelativeFileSet classPath : resourcesList) {

            File srcdir = classPath.getBaseDirectory();

            for (String fname : classPath.getIncludedFiles()) {

                copyEntry(javaDirectory, srcdir, fname);

            }

        }

    }

    private String getBundleName(Map<String, ? super Object> params) {

        if (MAC_CF_BUNDLE_NAME.fetchFrom(params) != null) {

            String bn = MAC_CF_BUNDLE_NAME.fetchFrom(params);

            if (bn.length() > 16) {

                Log.info(MessageFormat.format(I18N.getString(

                        "message.bundle-name-too-long-warning"), MAC_CF_BUNDLE_NAME.getID(), bn));

            }

            return MAC_CF_BUNDLE_NAME.fetchFrom(params);

        } else if (APP_NAME.fetchFrom(params) != null) {

            return APP_NAME.fetchFrom(params);

        } else {

            String nm = MAIN_CLASS.fetchFrom(params);

            if (nm.length() > 16) {

                nm = nm.substring(0, 16);

            }

            return nm;

        }

    }

    private void writeRuntimeInfoPlist(File file) throws IOException {

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

        String identifier = Arguments.CREATE_JRE_INSTALLER.fetchFrom(params) ?

                MAC_CF_BUNDLE_IDENTIFIER.fetchFrom(params) :

                "com.oracle.java." + MAC_CF_BUNDLE_IDENTIFIER.fetchFrom(params);

        data.put("CF_BUNDLE_IDENTIFIER", identifier);

        String name = Arguments.CREATE_JRE_INSTALLER.fetchFrom(params) ?

                getBundleName(params): "Java Runtime Image";

        data.put("CF_BUNDLE_NAME", name);

        data.put("CF_BUNDLE_VERSION", VERSION.fetchFrom(params));

        data.put("CF_BUNDLE_SHORT_VERSION_STRING", VERSION.fetchFrom(params));

        Writer w = new BufferedWriter(new FileWriter(file));

        w.write(preprocessTextResource(

                "package/macosx/Runtime-Info.plist",

                I18N.getString("resource.runtime-info-plist"),

                TEMPLATE_RUNTIME_INFO_PLIST,

                data,

                VERBOSE.fetchFrom(params),

                DROP_IN_RESOURCES_ROOT.fetchFrom(params)));

        w.close();

    }

    private void writeInfoPlist(File file) throws IOException {

        Log.verbose(MessageFormat.format(I18N.getString("message.preparing-info-plist"), file.getAbsolutePath()));

        //prepare config for exe

        //Note: do not need CFBundleDisplayName if we do not support localization

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