/*

 * Copyright (c) 2012, 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 javax.imageio.ImageIO;

import java.awt.image.BufferedImage;

import java.io.*;

import java.nio.file.Files;

import java.nio.file.attribute.PosixFilePermission;

import java.nio.file.attribute.PosixFilePermissions;

import java.text.MessageFormat;

import java.util.*;

import java.util.regex.Pattern;

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

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

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

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

public class LinuxDebBundler extends AbstractBundler {

    private static final ResourceBundle I18N = ResourceBundle.getBundle(

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

    public static final BundlerParamInfo<LinuxAppBundler> APP_BUNDLER =

            new StandardBundlerParam<>(

            "linux.app.bundler",

            LinuxAppBundler.class,

            params -> new LinuxAppBundler(),

            (s, p) -> null);

    // Debian rules for package naming are used here

    // https://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Source

    //

    // Package names must consist only of lower case letters (a-z),

    // digits (0-9), plus (+) and minus (-) signs, and periods (.).

    // They must be at least two characters long and

    // must start with an alphanumeric character.

    //

    private static final Pattern DEB_BUNDLE_NAME_PATTERN =

            Pattern.compile("^[a-z][a-z\\d\\+\\-\\.]+");

    public static final BundlerParamInfo<String> BUNDLE_NAME =

            new StandardBundlerParam<> (

            Arguments.CLIOptions.LINUX_BUNDLE_NAME.getId(),

            String.class,

            params -> {

                String nm = APP_NAME.fetchFrom(params);

                if (nm == null) return null;

                // make sure to lower case and spaces/underscores become dashes

                nm = nm.toLowerCase().replaceAll("[ _]", "-");

                return nm;

            },

            (s, p) -> {

                if (!DEB_BUNDLE_NAME_PATTERN.matcher(s).matches()) {

                    throw new IllegalArgumentException(new ConfigException(

                            MessageFormat.format(I18N.getString(

                            "error.invalid-value-for-package-name"), s),

                            I18N.getString(

                            "error.invalid-value-for-package-name.advice")));

                }

                return s;

            });

    public static final BundlerParamInfo<String> FULL_PACKAGE_NAME =

            new StandardBundlerParam<> (

            "linux.deb.fullPackageName",

            String.class,

            params -> BUNDLE_NAME.fetchFrom(params) + "-"

                    + VERSION.fetchFrom(params),

            (s, p) -> s);

    public static final BundlerParamInfo<File> DEB_IMAGE_DIR =

            new StandardBundlerParam<>(

            "linux.deb.imageDir",

            File.class,

            params -> {

                File imagesRoot = IMAGES_ROOT.fetchFrom(params);

                if (!imagesRoot.exists()) imagesRoot.mkdirs();

                return new File(new File(imagesRoot, "linux-deb.image"),

                        FULL_PACKAGE_NAME.fetchFrom(params));

            },

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

    public static final BundlerParamInfo<File> APP_IMAGE_ROOT =

            new StandardBundlerParam<>(

            "linux.deb.imageRoot",

            File.class,

            params -> {

                File imageDir = DEB_IMAGE_DIR.fetchFrom(params);

                return new File(imageDir, LINUX_INSTALL_DIR.fetchFrom(params));

            },

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

    public static final BundlerParamInfo<File> CONFIG_DIR =

            new StandardBundlerParam<>(

            "linux.deb.configDir",

            File.class,

            params ->  new File(DEB_IMAGE_DIR.fetchFrom(params), "DEBIAN"),

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

    public static final BundlerParamInfo<String> EMAIL =

            new StandardBundlerParam<> (

            Arguments.CLIOptions.LINUX_DEB_MAINTAINER.getId(),

            String.class,

            params -> "Unknown",

            (s, p) -> s);

    public static final BundlerParamInfo<String> MAINTAINER =

            new StandardBundlerParam<> (

            BundleParams.PARAM_MAINTAINER,

            String.class,

            params -> VENDOR.fetchFrom(params) + " <"

                    + EMAIL.fetchFrom(params) + ">",

            (s, p) -> s);

            new StandardBundlerParam<>(

            Arguments.CLIOptions.LINUX_CATEGORY.getId(),

            String.class,

            params -> "misc",

            (s, p) -> s);

    public static final BundlerParamInfo<String> LICENSE_TEXT =

            new StandardBundlerParam<> (

            "linux.deb.licenseText",

            String.class,

            params -> {

                try {

                    String licenseFile = LICENSE_FILE.fetchFrom(params);

                    if (licenseFile != null) {

                    }

                } catch (Exception e) {

                    Log.verbose(e);

                }

                return "Unknown";

            },

            (s, p) -> s);

    public static final BundlerParamInfo<String> XDG_FILE_PREFIX =

            new StandardBundlerParam<> (

            "linux.xdg-prefix",

            String.class,

            params -> {

                try {

                    String vendor;

                    if (params.containsKey(VENDOR.getID())) {

                        vendor = VENDOR.fetchFrom(params);

                    } else {

                        vendor = "jpackage";

                    }

                    String appName = APP_NAME.fetchFrom(params);

                    return (appName + "-" + vendor).replaceAll("\\s", "");

                } catch (Exception e) {

                    Log.verbose(e);

                }

                return "unknown-MimeInfo.xml";

            },

            (s, p) -> s);

    public 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 final static String DEFAULT_ICON = "javalogo_white_32.png";

    private final static String DEFAULT_CONTROL_TEMPLATE = "template.control";

    private final static String DEFAULT_PRERM_TEMPLATE = "template.prerm";

    private final static String DEFAULT_PREINSTALL_TEMPLATE =

            "template.preinst";

    private final static String DEFAULT_POSTRM_TEMPLATE = "template.postrm";

    private final static String DEFAULT_POSTINSTALL_TEMPLATE =

            "template.postinst";

    private final static String DEFAULT_COPYRIGHT_TEMPLATE =

            "template.copyright";

    private final static String DEFAULT_DESKTOP_FILE_TEMPLATE =

            "template.desktop";

    private final static String TOOL_DPKG_DEB = "dpkg-deb";

    private final static String TOOL_DPKG = "dpkg";

    public static boolean testTool(String toolName, String minVersion) {

        try {

            ProcessBuilder pb = new ProcessBuilder(

                    toolName,

                    "--version");

            // not interested in the output

            IOUtils.exec(pb, true, null);

        } catch (Exception e) {

            Log.verbose(MessageFormat.format(I18N.getString(

                    "message.test-for-tool"), toolName, e.getMessage()));

            return false;

        }

        return true;

    }

    @Override

    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);

            // NOTE: Can we validate that the required tools are available

            // before we start?

            if (!testTool(TOOL_DPKG_DEB, "1")){

                throw new ConfigException(MessageFormat.format(

                        I18N.getString("error.tool-not-found"), TOOL_DPKG_DEB),

                        I18N.getString("error.tool-not-found.advice"));

            }

            if (!testTool(TOOL_DPKG, "1")){

                throw new ConfigException(MessageFormat.format(

                        I18N.getString("error.tool-not-found"), TOOL_DPKG),

                        I18N.getString("error.tool-not-found.advice"));

            }

            // Show warning is license file is missing

            String licenseFile = LICENSE_FILE.fetchFrom(params);

            if (licenseFile == null) {

                Log.verbose(I18N.getString("message.debs-like-licenses"));

            }

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

            List<Map<String, ? super Object>> associations =

                    FILE_ASSOCIATIONS.fetchFrom(params);

            if (associations != null) {

                for (int i = 0; i < associations.size(); i++) {

                    Map<String, ? super Object> assoc = associations.get(i);

                    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), i),

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

                    } else if (mimes.size() > 1) {

                        String msgKey =

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

                        throw new ConfigException(

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

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

                    }

                }

            }

            // bundle name has some restrictions

            // the string converter will throw an exception if invalid

            BUNDLE_NAME.getStringConverter().apply(

                    BUNDLE_NAME.fetchFrom(params), params);

            return true;

        } catch (RuntimeException re) {

            if (re.getCause() instanceof ConfigException) {

                throw (ConfigException) re.getCause();

            } else {

                throw new ConfigException(re);

            }

        }

    }

    private boolean prepareProto(Map<String, ? super Object> params)

            throws PackagerException, IOException {

        File appImage = StandardBundlerParam.getPredefinedAppImage(params);

        File appDir = null;

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

        if (appImage != null) {

            appDir = new File(APP_IMAGE_ROOT.fetchFrom(params),

                APP_NAME.fetchFrom(params));

            // copy everything from appImage dir into appDir/name

            IOUtils.copyRecursive(appImage.toPath(), appDir.toPath());

        } else {

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

                    APP_IMAGE_ROOT.fetchFrom(params), true);

        }

        return appDir != null;

    }

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

            File outdir) throws PackagerException {

        IOUtils.writableOutputDir(outdir.toPath());

        // we want to create following structure

        //   <package-name>

        //        DEBIAN

        //          control   (file with main package details)

        //          menu      (request to create menu)

        //          ... other control files if needed ....

        //        opt  (by default)

        //          AppFolder (this is where app image goes)

        //             launcher executable

        //             app

        //             runtime

        File imageDir = DEB_IMAGE_DIR.fetchFrom(params);

        File configDir = CONFIG_DIR.fetchFrom(params);

        try {

            imageDir.mkdirs();

            configDir.mkdirs();

            if (prepareProto(params) && prepareProjectConfig(params)) {

                return buildDeb(params, outdir);

            }

            return null;

        } catch (IOException ex) {

            Log.verbose(ex);

            throw new PackagerException(ex);

        }

    }

    /*

     * set permissions with a string like "rwxr-xr-x"

     *

     * This cannot be directly backport to 22u which is built with 1.6

     */

    private void setPermissions(File file, String permissions) {

        Set<PosixFilePermission> filePermissions =

                PosixFilePermissions.fromString(permissions);

        try {

            if (file.exists()) {

                Files.setPosixFilePermissions(file.toPath(), filePermissions);

            }

        } catch (IOException ex) {

            Log.error(ex.getMessage());

            Log.verbose(ex);

        }

    }

    private static String getDebArch() throws IOException {

        try (var baos = new ByteArrayOutputStream();

                var ps = new PrintStream(baos)) {

            var pb = new ProcessBuilder(TOOL_DPKG, "--print-architecture");

            IOUtils.exec(pb, false, ps);

            return baos.toString().split("\n", 2)[0];

        }

    }

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

        return getInstalledSizeKB(APP_IMAGE_ROOT.fetchFrom(params)) >> 10;

    }

    private long getInstalledSizeKB(File dir) {

        long count = 0;

        File[] children = dir.listFiles();

        if (children != null) {

            for (File file : children) {

                if (file.isFile()) {

                    count += file.length();

                }

                else if (file.isDirectory()) {

                    count += getInstalledSizeKB(file);

                }

            }

        }

        return count;

    }

    private boolean prepareProjectConfig(Map<String, ? super Object> params)

            throws IOException {

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

        File rootDir = LinuxAppBundler.getRootDir(APP_IMAGE_ROOT.fetchFrom(

                params), params);

        File binDir = new File(rootDir, "bin");

        File iconTarget = getConfig_IconFile(binDir, params);

        File icon = ICON_PNG.fetchFrom(params);

        if (!StandardBundlerParam.isRuntimeInstaller(params)) {

            // prepare installer icon

            if (icon == null || !icon.exists()) {

                fetchResource(iconTarget.getName(),

                        I18N.getString("resource.menu-icon"),

                        DEFAULT_ICON,

                        iconTarget,

                        VERBOSE.fetchFrom(params),

                        RESOURCE_DIR.fetchFrom(params));

            } else {

                fetchResource(iconTarget.getName(),

                        I18N.getString("resource.menu-icon"),

                        icon,

                        iconTarget,

                        VERBOSE.fetchFrom(params),

                        RESOURCE_DIR.fetchFrom(params));

            }

        }

        StringBuilder installScripts = new StringBuilder();

        StringBuilder removeScripts = new StringBuilder();

        for (Map<String, ? super Object> addLauncher :

                ADD_LAUNCHERS.fetchFrom(params)) {

            Map<String, String> addLauncherData =

                    createReplacementData(addLauncher);

            addLauncherData.put("APPLICATION_FS_NAME",

                    data.get("APPLICATION_FS_NAME"));

            addLauncherData.put("DESKTOP_MIMES", "");

            if (!StandardBundlerParam.isRuntimeInstaller(params)) {

                // prepare desktop shortcut

                try (Writer w = Files.newBufferedWriter(

                        getConfig_DesktopShortcutFile(

                                binDir, addLauncher).toPath())) {

                    String content = preprocessTextResource(

                            getConfig_DesktopShortcutFile(binDir,

                            addLauncher).getName(),

                            I18N.getString("resource.menu-shortcut-descriptor"),

                            DEFAULT_DESKTOP_FILE_TEMPLATE,

                            addLauncherData,

                            VERBOSE.fetchFrom(params),

                            RESOURCE_DIR.fetchFrom(params));

                    w.write(content);

                }

            }

            // prepare installer icon

            iconTarget = getConfig_IconFile(binDir, addLauncher);

            icon = ICON_PNG.fetchFrom(addLauncher);

            if (icon == null || !icon.exists()) {

                fetchResource(iconTarget.getName(),

                        I18N.getString("resource.menu-icon"),

                        DEFAULT_ICON,

                        iconTarget,

                        VERBOSE.fetchFrom(params),

                        RESOURCE_DIR.fetchFrom(params));

            } else {

                fetchResource(iconTarget.getName(),

                        I18N.getString("resource.menu-icon"),

                        icon,

                        iconTarget,

                        VERBOSE.fetchFrom(params),

                        RESOURCE_DIR.fetchFrom(params));

            }

            // postinst copying of desktop icon

            installScripts.append(

                    "        xdg-desktop-menu install --novendor ");

            installScripts.append(LINUX_INSTALL_DIR.fetchFrom(params));

            installScripts.append("/");

            installScripts.append(data.get("APPLICATION_FS_NAME"));

            installScripts.append("/bin/");

            installScripts.append(

                    addLauncherData.get("APPLICATION_LAUNCHER_FILENAME"));

            installScripts.append(".desktop\n");

            // postrm cleanup of desktop icon

            removeScripts.append(

                    "        xdg-desktop-menu uninstall --novendor ");

            removeScripts.append(LINUX_INSTALL_DIR.fetchFrom(params));

            removeScripts.append("/");

            removeScripts.append(data.get("APPLICATION_FS_NAME"));

            removeScripts.append("/bin/");

            removeScripts.append(

                    addLauncherData.get("APPLICATION_LAUNCHER_FILENAME"));

            removeScripts.append(".desktop\n");

        }

        data.put("ADD_LAUNCHERS_INSTALL", installScripts.toString());