/*

 * 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.awt.image.BufferedImage;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Writer;

import java.nio.file.Files;

import java.nio.file.Path;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.ResourceBundle;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import javax.imageio.ImageIO;

import javax.xml.stream.XMLOutputFactory;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import static jdk.jpackage.internal.LinuxAppBundler.LINUX_INSTALL_DIR;

import static jdk.jpackage.internal.LinuxAppBundler.LINUX_PACKAGE_DEPENDENCIES;

import static jdk.jpackage.internal.LinuxAppImageBuilder.DEFAULT_ICON;

import static jdk.jpackage.internal.LinuxAppImageBuilder.ICON_PNG;

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

abstract class LinuxPackageBundler extends AbstractBundler {

    protected static final ResourceBundle I18N = ResourceBundle.getBundle(

            "jdk.jpackage.internal.resources.LinuxResources");

    private static final String DESKTOP_COMMANDS_INSTALL = "DESKTOP_COMMANDS_INSTALL";

    private static final String DESKTOP_COMMANDS_UNINSTALL = "DESKTOP_COMMANDS_UNINSTALL";

    private static final String UTILITY_SCRIPTS = "UTILITY_SCRIPTS";

    private static final BundlerParamInfo<LinuxAppBundler> APP_BUNDLER =

        new StandardBundlerParam<>(

                "linux.app.bundler",

                LinuxAppBundler.class,

                (params) -> new LinuxAppBundler(),

                null

        );

    private static final BundlerParamInfo<String> MENU_GROUP =

        new StandardBundlerParam<>(

                Arguments.CLIOptions.LINUX_MENU_GROUP.getId(),

                String.class,

                params -> I18N.getString("param.menu-group.default"),

                (s, p) -> s

        );

    private static final StandardBundlerParam<Boolean> SHORTCUT_HINT =

        new StandardBundlerParam<>(

                Arguments.CLIOptions.LINUX_SHORTCUT_HINT.getId(),

                Boolean.class,

                params -> false,

                (s, p) -> (s == null || "null".equalsIgnoreCase(s))

                        ? false : Boolean.valueOf(s)

        );

    LinuxPackageBundler(BundlerParamInfo<String> packageName) {

        this.packageName = packageName;

    }

    private final BundlerParamInfo<String> packageName;

    @Override

    final public boolean validate(Map<String, ? super Object> params)

            throws ConfigException {

        try {

            if (params == null) throw new ConfigException(

                    I18N.getString("error.parameters-null"),

                    I18N.getString("error.parameters-null.advice"));

            // run basic validation to ensure requirements are met

            // we are not interested in return code, only possible exception

            APP_BUNDLER.fetchFrom(params).validate(params);

            validateFileAssociations(FILE_ASSOCIATIONS.fetchFrom(params));

            // If package name has some restrictions, the string converter will

            // throw an exception if invalid

            packageName.getStringConverter().apply(packageName.fetchFrom(params),

                params);

            // Packaging specific validation

            doValidate(params);

            return true;

        } catch (RuntimeException re) {

            if (re.getCause() instanceof ConfigException) {

                throw (ConfigException) re.getCause();

            } else {

                throw new ConfigException(re);

            }

        }

    }

    @Override

    final public String getBundleType() {

        return "INSTALLER";

    }

    @Override

    final public File execute(Map<String, ? super Object> params,

            File outputParentDir) throws PackagerException {

        IOUtils.writableOutputDir(outputParentDir.toPath());

        PlatformPackage thePackage = createMetaPackage(params);

        try {

            File appImage = StandardBundlerParam.getPredefinedAppImage(params);

            // we either have an application image or need to build one

            if (appImage != null) {

                appImageLayout(params).resolveAt(appImage.toPath()).copy(

                        thePackage.sourceApplicationLayout());

            } else {

                appImage = APP_BUNDLER.fetchFrom(params).doBundle(params,

                        thePackage.sourceRoot().toFile(), true);

                ApplicationLayout srcAppLayout = appImageLayout(params).resolveAt(

                        appImage.toPath());

                if (appImage.equals(PREDEFINED_RUNTIME_IMAGE.fetchFrom(params))) {

                    // Application image points to run-time image.

                    // Copy it.

                    srcAppLayout.copy(thePackage.sourceApplicationLayout());

                } else {

                    // Application image is a newly created directory tree.

                    // Move it.

                    srcAppLayout.move(thePackage.sourceApplicationLayout());

                    if (appImage.exists()) {

                        // Empty app image directory might remain after all application

                        // directories have been moved.

                        appImage.delete();

                    }

                }

            }

            Map<String, String> data = createDefaultReplacementData(params);

            if (StandardBundlerParam.isRuntimeInstaller(params)) {

                Stream.of(DESKTOP_COMMANDS_INSTALL, DESKTOP_COMMANDS_UNINSTALL,

                        UTILITY_SCRIPTS).forEach(v -> data.put(v, ""));

            } else {

                data.putAll(

                        new DesktopIntegration(thePackage, params).prepareForApplication());

            }

            data.putAll(createReplacementData(params));

            return buildPackageBundle(Collections.unmodifiableMap(data), params,

                    outputParentDir);

        } catch (IOException ex) {

            Log.verbose(ex);

            throw new PackagerException(ex);

        }

    }

    private Map<String, String> createDefaultReplacementData(

            Map<String, ? super Object> params) throws IOException {

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

        data.put("APPLICATION_PACKAGE", createMetaPackage(params).name());

        data.put("APPLICATION_VENDOR", VENDOR.fetchFrom(params));

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

        data.put("APPLICATION_DESCRIPTION", DESCRIPTION.fetchFrom(params));

        data.put("APPLICATION_RELEASE", RELEASE.fetchFrom(params));

        data.put("PACKAGE_DEPENDENCIES", LINUX_PACKAGE_DEPENDENCIES.fetchFrom(

                params));

        return data;

    }

    abstract void doValidate(Map<String, ? super Object> params)

            throws ConfigException;

    abstract protected Map<String, String> createReplacementData(

            Map<String, ? super Object> params) throws IOException;

    abstract protected File buildPackageBundle(

            Map<String, String> replacementData,

            Map<String, ? super Object> params, File outputParentDir) throws

            PackagerException, IOException;

    final protected PlatformPackage createMetaPackage(

            Map<String, ? super Object> params) {

        return new PlatformPackage() {

            @Override

            public String name() {

                return packageName.fetchFrom(params);

            }

            @Override

            public Path sourceRoot() {

                return IMAGES_ROOT.fetchFrom(params).toPath().toAbsolutePath();

            }

            @Override

            public ApplicationLayout sourceApplicationLayout() {

                return appImageLayout(params).resolveAt(

                        applicationInstallDir(sourceRoot()));

            }

            @Override

            public ApplicationLayout installedApplicationLayout() {

                return appImageLayout(params).resolveAt(

                        applicationInstallDir(Path.of("/")));

            }

            private Path applicationInstallDir(Path root) {

                Path installDir = Path.of(LINUX_INSTALL_DIR.fetchFrom(params),

                        name());

                if (installDir.isAbsolute()) {

                    installDir = Path.of("." + installDir.toString()).normalize();

                }

                return root.resolve(installDir);

            }

        };

    }

    private ApplicationLayout appImageLayout(

            Map<String, ? super Object> params) {

        if (StandardBundlerParam.isRuntimeInstaller(params)) {

            return ApplicationLayout.javaRuntime();

        }

        return ApplicationLayout.unixApp();

    }

    private static void validateFileAssociations(

            List<Map<String, ? super Object>> associations) throws

            ConfigException {

        // only one mime type per association, at least one file extention

        int assocIdx = 0;

        for (var assoc : associations) {

            ++assocIdx;

            List<String> mimes = FA_CONTENT_TYPE.fetchFrom(assoc);

            if (mimes == null || mimes.isEmpty()) {

                String msgKey = "error.no-content-types-for-file-association";

                throw new ConfigException(

                        MessageFormat.format(I18N.getString(msgKey), assocIdx),

                        I18N.getString(msgKey + ".advise"));

            }

            if (mimes.size() > 1) {

                String msgKey = "error.too-many-content-types-for-file-association";

                throw new ConfigException(

                        MessageFormat.format(I18N.getString(msgKey), assocIdx),

                        I18N.getString(msgKey + ".advise"));

            }

        }

    }

    /**

     * Helper to create files for desktop integration.

     */

    private class DesktopIntegration {

        DesktopIntegration(PlatformPackage thePackage,

                Map<String, ? super Object> params) {

            associations = FILE_ASSOCIATIONS.fetchFrom(params).stream().filter(

                    a -> {

                        if (a == null) {

                            return false;

                        }

                        List<String> mimes = FA_CONTENT_TYPE.fetchFrom(a);

                        return (mimes != null && !mimes.isEmpty());

                    }).collect(Collectors.toUnmodifiableList());

            launchers = ADD_LAUNCHERS.fetchFrom(params);

            this.thePackage = thePackage;

            customIconFile = ICON_PNG.fetchFrom(params);

            verbose = VERBOSE.fetchFrom(params);

            resourceDir = RESOURCE_DIR.fetchFrom(params);

            // XDG recommends to use vendor prefix in desktop file names as xdg

            // commands copy files to system directories.

            // Package name should be a good prefix.

            final String desktopFileName = String.format("%s-%s.desktop",

                        thePackage.name(), APP_NAME.fetchFrom(params));

            final String mimeInfoFileName = String.format("%s-%s-MimeInfo.xml",

                        thePackage.name(), APP_NAME.fetchFrom(params));

            mimeInfoFile = new DesktopFile(mimeInfoFileName);

            if (!associations.isEmpty() || SHORTCUT_HINT.fetchFrom(params) || customIconFile != null) {

                //

                // Create primary .desktop file if one of conditions is met:

                // - there are file associations configured

                // - user explicitely requested to create a shortcut

                // - custom icon specified

                //

                desktopFile = new DesktopFile(desktopFileName);

                iconFile = new DesktopFile(String.format("%s.png",

                        APP_NAME.fetchFrom(params)));

            } else {

                desktopFile = null;

                iconFile = null;

            }

            this.desktopFileData = Collections.unmodifiableMap(

                    createDataForDesktopFile(params));

        }

        Map<String, String> prepareForApplication() throws IOException {

            if (iconFile != null) {

                // Create application icon file.

                prepareSrcIconFile();

            }

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

            final ShellCommands shellCommands;

            if (desktopFile != null) {

                // Create application desktop description file.

                createDesktopFile(data);

                // Shell commands will be created only if desktop file

                // should be installed.

                shellCommands = new ShellCommands();

            } else {

                shellCommands = null;

            }

            if (!associations.isEmpty()) {

                // Create XML file with mime types corresponding to file associations.

                createFileAssociationsMimeInfoFile();

                shellCommands.setFileAssociations();

                // Create icon files corresponding to file associations

                Map<String, Path> mimeTypeWithIconFile = createFileAssociationIconFiles();

                mimeTypeWithIconFile.forEach((k, v) -> {

                    shellCommands.addIcon(k, v);

                });

            }

            // Create shell commands to install/uninstall integration with desktop of the app.

            if (shellCommands != null) {

                shellCommands.applyTo(data);

            }

            boolean needCleanupScripts = !associations.isEmpty();

            // Take care of additional launchers if there are any.

            // Process every additional launcher as the main application launcher.

            // Collect shell commands to install/uninstall integration with desktop

            // of the additional launchers and append them to the corresponding

            // commands of the main launcher.

            List<String> installShellCmds = new ArrayList<>(Arrays.asList(

                    data.get(DESKTOP_COMMANDS_INSTALL)));

            List<String> uninstallShellCmds = new ArrayList<>(Arrays.asList(

                    data.get(DESKTOP_COMMANDS_UNINSTALL)));

            for (Map<String, ? super Object> params : launchers) {

                DesktopIntegration integration = new DesktopIntegration(

                        thePackage, params);

                if (!integration.associations.isEmpty()) {

                    needCleanupScripts = true;

                }

                Map<String, String> launcherData = integration.prepareForApplication();

                installShellCmds.add(launcherData.get(DESKTOP_COMMANDS_INSTALL));

                uninstallShellCmds.add(launcherData.get(

                        DESKTOP_COMMANDS_UNINSTALL));

            }

            data.put(DESKTOP_COMMANDS_INSTALL, stringifyShellCommands(

                    installShellCmds));

            data.put(DESKTOP_COMMANDS_UNINSTALL, stringifyShellCommands(

                    uninstallShellCmds));

            if (needCleanupScripts) {

                // Pull in utils.sh scrips library.

                try (InputStream is = getResourceAsStream("utils.sh");

                        InputStreamReader isr = new InputStreamReader(is);

                        BufferedReader reader = new BufferedReader(isr)) {

                    data.put(UTILITY_SCRIPTS, reader.lines().collect(

                            Collectors.joining(System.lineSeparator())));

                }

            } else {

                data.put(UTILITY_SCRIPTS, "");

            }

            return data;

        }

        private Map<String, String> createDataForDesktopFile(

                Map<String, ? super Object> params) {

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

            data.put("APPLICATION_NAME", APP_NAME.fetchFrom(params));

            data.put("APPLICATION_DESCRIPTION", DESCRIPTION.fetchFrom(params));

            data.put("APPLICATION_ICON",

                    iconFile != null ? iconFile.installPath().toString() : null);

            data.put("DEPLOY_BUNDLE_CATEGORY", MENU_GROUP.fetchFrom(params));

            data.put("APPLICATION_LAUNCHER",

                    thePackage.installedApplicationLayout().launchersDirectory().resolve(

                            LinuxAppImageBuilder.getLauncherName(params)).toString());

            return data;

        }

        /**

         * Shell commands to integrate something with desktop.

         */

        private class ShellCommands {

            ShellCommands() {

                registerIconCmds = new ArrayList<>();

                unregisterIconCmds = new ArrayList<>();

                registerDesktopFileCmd = String.join(" ", "xdg-desktop-menu",

                        "install", desktopFile.installPath().toString());

                unregisterDesktopFileCmd = String.join(" ", "xdg-desktop-menu",

                        "uninstall", desktopFile.installPath().toString());

            }

            void setFileAssociations() {

                registerFileAssociationsCmd = String.join(" ", "xdg-mime",

                        "install",

                        mimeInfoFile.installPath().toString());

                unregisterFileAssociationsCmd = String.join(" ", "xdg-mime",

                        "uninstall", mimeInfoFile.installPath().toString());

                //

                // Add manual cleanup of system files to get rid of

                // the default mime type handlers.

                //

                // Even after mime type is unregisterd with `xdg-mime uninstall`

                // command and desktop file deleted with `xdg-desktop-menu uninstall`

                // command, records in

                // `/usr/share/applications/defaults.list` (Ubuntu 16) or

                // `/usr/local/share/applications/defaults.list` (OracleLinux 7)

                // files remain referencing deleted mime time and deleted

                // desktop file which makes `xdg-mime query default` output name

                // of non-existing desktop file.

                //

                String cleanUpCommand = String.join(" ",

                        "uninstall_default_mime_handler",

                        desktopFile.installPath().getFileName().toString(),

                        String.join(" ", getMimeTypeNamesFromFileAssociations()));

                unregisterFileAssociationsCmd = stringifyShellCommands(

                        unregisterFileAssociationsCmd, cleanUpCommand);

            }

            void addIcon(String mimeType, Path iconFile) {

                final int imgSize = getSquareSizeOfImage(iconFile.toFile());

                final String dashMime = mimeType.replace('/', '-');

                registerIconCmds.add(String.join(" ", "xdg-icon-resource",

                        "install", "--context", "mimetypes", "--size ",

                        Integer.toString(imgSize), iconFile.toString(), dashMime));

                unregisterIconCmds.add(String.join(" ", "xdg-icon-resource",

                        "uninstall", dashMime));

            }

            void applyTo(Map<String, String> data) {

                List<String> cmds = new ArrayList<>();

                cmds.add(registerDesktopFileCmd);

                cmds.add(registerFileAssociationsCmd);

                cmds.addAll(registerIconCmds);

                data.put(DESKTOP_COMMANDS_INSTALL, stringifyShellCommands(cmds));

                cmds.clear();

                cmds.add(unregisterDesktopFileCmd);

                cmds.add(unregisterFileAssociationsCmd);

                cmds.addAll(unregisterIconCmds);

                data.put(DESKTOP_COMMANDS_UNINSTALL, stringifyShellCommands(cmds));

            }

            private String registerDesktopFileCmd;

            private String unregisterDesktopFileCmd;

            private String registerFileAssociationsCmd;

            private String unregisterFileAssociationsCmd;

            private List<String> registerIconCmds;

            private List<String> unregisterIconCmds;

        }

        private final PlatformPackage thePackage;

        private final List<Map<String, ? super Object>> associations;

        private final List<Map<String, ? super Object>> launchers;

        /**

         * Desktop integration file. xml, icon, etc.

         * Resides somewhere in application installation tree.

         * Has two paths:

         *  - path where it should be placed at package build time;

         *  - path where it should be installed by package manager;