/*

 * Copyright (c) 2012, 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.jpackage.internal;

import jdk.jpackage.internal.*;

import jdk.jpackage.internal.Arguments;

import jdk.jpackage.internal.BundleParams;

import jdk.jpackage.internal.resources.LinuxResources;

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.logging.Level;

import java.util.logging.Logger;

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(

    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<> (

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

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

            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<> (

            I18N.getString("param.full-package-name.name"),

            I18N.getString("param.full-package-name.description"),

            "linux.deb.fullPackageName",

            String.class,

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

                    + VERSION.fetchFrom(params),

            (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 ->  new File(BUILD_ROOT.fetchFrom(params), "linux"),

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

    public static final BundlerParamInfo<File> DEB_IMAGE_DIR =

            new StandardBundlerParam<>(

            I18N.getString("param.image-dir.name"),

            I18N.getString("param.image-dir.description"),

            "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<>(

            I18N.getString("param.app-image-root.name"),

            I18N.getString("param.app-image-root.description"),

            "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<>(

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

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

            "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<> (

            I18N.getString("param.maintainer-email.name"),

            I18N.getString("param.maintainer-email.description"),

            BundleParams.PARAM_EMAIL,

            String.class,

            params -> "Unknown",

            (s, p) -> s);

    public static final BundlerParamInfo<String> MAINTAINER =

            new StandardBundlerParam<> (

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

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

            Arguments.CLIOptions.LINUX_DEB_MAINTAINER.getId(),

            String.class,

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

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

            (s, p) -> s);

    public static final BundlerParamInfo<String> LICENSE_TEXT =

            new StandardBundlerParam<> (

            I18N.getString("param.license-text.name"),

            I18N.getString("param.license-text.description"),

            "linux.deb.licenseText",

            String.class,

            params -> {

                try {

                    List<String> licenseFiles = LICENSE_FILE.fetchFrom(params);

                    //need to copy license file to the root of linux-app.image

                    if (licenseFiles.size() > 0) {

                        String licFileStr = licenseFiles.get(0);

                        for (RelativeFileSet rfs :

                                APP_RESOURCES_LIST.fetchFrom(params)) {

                            if (rfs.contains(licFileStr)) {

                                return new String(Files.readAllBytes((

                                        new File(rfs.getBaseDirectory(),

                                        licFileStr)).toPath()));

                            }

                        }

                    }

                } catch (Exception e) {

                    if (Log.isDebug()) {

                        e.printStackTrace();

                    }

                }

                return "Unknown";

            },

            (s, p) -> s);

    public static final BundlerParamInfo<String> XDG_FILE_PREFIX =

            new StandardBundlerParam<> (

            I18N.getString("param.xdg-prefix.name"),

            I18N.getString("param.xdg-prefix.description"),

            "linux.xdg-prefix",

            String.class,

            params -> {

                try {

                    String vendor;

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

                        vendor = VENDOR.fetchFrom(params);

                    } else {

                        vendor = "jpackage";

                    }

                    String appName = APP_FS_NAME.fetchFrom(params);

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

                } catch (Exception e) {

                    if (Log.isDebug()) {

                        e.printStackTrace();

                    }

                }

                return "unknown-MimeInfo.xml";

            },

            (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";

    public final static String TOOL_DPKG = "dpkg-deb";

    public LinuxDebBundler() {

        super();

        baseResourceLoader = LinuxResources.class;

    }

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

        try {

            ProcessBuilder pb = new ProcessBuilder(

                    toolName,

                    "--version");

            // not interested in the output

            IOUtils.exec(pb, Log.isDebug(), true);

        } 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> p)

            throws UnsupportedPlatformException, ConfigException {

        try {

            if (p == 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(p).doValidate(p);

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

            // before we start?

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

            }

            // validate license file, if used, exists in the proper place

            if (p.containsKey(LICENSE_FILE.getID())) {

                List<RelativeFileSet> appResourcesList =

                        APP_RESOURCES_LIST.fetchFrom(p);

                for (String license : LICENSE_FILE.fetchFrom(p)) {

                    boolean found = false;

                    for (RelativeFileSet appResources : appResourcesList) {

                        found = found || appResources.contains(license);

                    }

                    if (!found) {

                        throw new ConfigException(

                                I18N.getString("error.license-missing"),

                                MessageFormat.format(I18N.getString(

                                        "error.license-missing.advice"),

                                        license));

                    }

                }

            } else {

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

            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(p), p);

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

            throws IOException {

        File appImage = StandardBundlerParam.getPredefinedAppImage(p);

        File appDir = null;

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

        if (appImage != null) {

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

                APP_NAME.fetchFrom(p));

            // copy everything from appImage dir into appDir/name

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

        } else {

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

                    APP_IMAGE_ROOT.fetchFrom(p), true);

        }

        return appDir != null;

    }

    //@Override

    public File bundle(Map<String, ? super Object> p, File outdir) {

        if (!outdir.isDirectory() && !outdir.mkdirs()) {

            throw new RuntimeException(MessageFormat.format(

                    I18N.getString("error.cannot-create-output-dir"),

                    outdir.getAbsolutePath()));

        }

        if (!outdir.canWrite()) {

            throw new RuntimeException(MessageFormat.format(

                    I18N.getString("error.cannot-write-to-output-dir"),

                    outdir.getAbsolutePath()));

        }

        // 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(p);

        File configDir = CONFIG_DIR.fetchFrom(p);

        try {

            imageDir.mkdirs();

            configDir.mkdirs();

            if (prepareProto(p) && prepareProjectConfig(p)) {

                return buildDeb(p, outdir);

            }

            return null;

        } catch (IOException ex) {

            ex.printStackTrace();

            return null;

        } finally {

            try {

                if (imageDir != null &&

                        PREDEFINED_APP_IMAGE.fetchFrom(p) == null &&

                        (PREDEFINED_RUNTIME_IMAGE.fetchFrom(p) == null ||

                        !Arguments.CREATE_JRE_INSTALLER.fetchFrom(p)) &&

                        !Log.isDebug() &&

                        !Log.isVerbose()) {

                    IOUtils.deleteRecursive(imageDir);

                } else if (imageDir != null) {

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

                            "message.debug-working-directory"),

                            imageDir.getAbsolutePath()));

                }

            } catch (IOException ex) {

                //noinspection ReturnInsideFinallyBlock

                Log.debug(ex.getMessage());

                return null;

            }

        }

    }

    /*

     * 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) {

            Logger.getLogger(LinuxDebBundler.class.getName()).log(

                    Level.SEVERE, null, ex);

        }

    }

    private String getArch() {

        String arch = System.getProperty("os.arch");

        if ("i386".equals(arch))

            return "i386";

        else

            return "amd64";

    }

    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 iconTarget = getConfig_IconFile(rootDir, params);

        File icon = ICON_PNG.fetchFrom(params);

        if (!Arguments.CREATE_JRE_INSTALLER.fetchFrom(params)) {

            // prepare installer icon

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

                fetchResource(LinuxAppBundler.BUNDLER_PREFIX

                        + iconTarget.getName(),

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

                        DEFAULT_ICON,

                        iconTarget,

                        VERBOSE.fetchFrom(params),

                        DROP_IN_RESOURCES_ROOT.fetchFrom(params));

            } else {

                fetchResource(LinuxAppBundler.BUNDLER_PREFIX

                        + iconTarget.getName(),

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

                        icon,

                        iconTarget,

                        VERBOSE.fetchFrom(params),

                        DROP_IN_RESOURCES_ROOT.fetchFrom(params));

            }

        }

        StringBuilder installScripts = new StringBuilder();

        StringBuilder removeScripts = new StringBuilder();

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

                SECONDARY_LAUNCHERS.fetchFrom(params)) {

            Map<String, String> secondaryLauncherData =

                    createReplacementData(secondaryLauncher);

            secondaryLauncherData.put("APPLICATION_FS_NAME",

                    data.get("APPLICATION_FS_NAME"));

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

            if (!Arguments.CREATE_JRE_INSTALLER.fetchFrom(params)) {

                // prepare desktop shortcut

                Writer w = new BufferedWriter(new FileWriter(

                        getConfig_DesktopShortcutFile(

                                rootDir, secondaryLauncher)));

                String content = preprocessTextResource(

                        LinuxAppBundler.BUNDLER_PREFIX

                                + getConfig_DesktopShortcutFile(rootDir,

                                        secondaryLauncher).getName(),

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

                        DEFAULT_DESKTOP_FILE_TEMPLATE,

                        secondaryLauncherData,

                        VERBOSE.fetchFrom(params),

                        DROP_IN_RESOURCES_ROOT.fetchFrom(params));

                w.write(content);