/*

 * 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.charset.StandardCharsets;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.StandardCopyOption;

import java.nio.file.attribute.BasicFileAttributes;

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 java.util.stream.Stream;

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;

            });

    private static final BundlerParamInfo<String> FULL_PACKAGE_NAME =

            new StandardBundlerParam<>(

                    "linux.deb.fullPackageName", String.class, params -> {

                        try {

                            return BUNDLE_NAME.fetchFrom(params)

                            + "_" + VERSION.fetchFrom(params)

                            + "-" + RELEASE.fetchFrom(params)

                            + "_" + getDebArch();

                        } catch (IOException ex) {

                            Log.verbose(ex);

                            return null;

                        }

                    }, (s, p) -> s);

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

    public static final BundlerParamInfo<String> SECTION =

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

                        StringBuilder contentBuilder = new StringBuilder();

                        try (Stream<String> stream = Files.lines(Path.of(

                                licenseFile), StandardCharsets.UTF_8)) {

                            stream.forEach(s -> contentBuilder.append(s).append(

                                    "\n"));

                        }

                        return contentBuilder.toString();

                    }

                } catch (Exception e) {

                    Log.verbose(e);

                }

                return "Unknown";

            },

            (s, p) -> s);

    public static final BundlerParamInfo<String> COPYRIGHT_FILE =

            new StandardBundlerParam<>(

            Arguments.CLIOptions.LINUX_DEB_COPYRIGHT_FILE.getId(),

            String.class,

            params -> null,

            (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 = "java32.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);

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

        if (appImage != null) {

            // copy everything from appImage dir into appDir/name

            IOUtils.copyRecursive(appImage.toPath(),

                    getConfig_RootDirectory(params).toPath());

        } else {

            File bundleDir = APP_BUNDLER.fetchFrom(params).doBundle(params,

                    APP_IMAGE_ROOT.fetchFrom(params), true);

            if (bundleDir == null) {

                return false;

            }

            Files.move(bundleDir.toPath(), getConfig_RootDirectory(

                    params).toPath(), StandardCopyOption.REPLACE_EXISTING);

        }

        return true;

    }

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

                adjustPermissionsRecursive(imageDir);

                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 void adjustPermissionsRecursive(File dir) throws IOException {

        Files.walkFileTree(dir.toPath(), new SimpleFileVisitor<Path>() {

            @Override

            public FileVisitResult visitFile(Path file,

                    BasicFileAttributes attrs)

                    throws IOException {

                if (file.endsWith(".so") || !Files.isExecutable(file)) {

                    setPermissions(file.toFile(), "rw-r--r--");

                } else if (Files.isExecutable(file)) {

                    setPermissions(file.toFile(), "rwxr-xr-x");

                }

                return FileVisitResult.CONTINUE;

            }

            @Override

            public FileVisitResult postVisitDirectory(Path dir, IOException e)

                    throws IOException {

                if (e == null) {

                    setPermissions(dir.toFile(), "rwxr-xr-x");

                    return FileVisitResult.CONTINUE;

                } else {

                    // directory iteration failed

                    throw e;

                }

            }

        });

    }

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

            throws IOException {

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

        File rootDir = getConfig_RootDirectory(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