/*

 * 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.io.IOException;

import java.nio.charset.StandardCharsets;

import java.nio.file.Path;

import java.util.*;

import java.util.function.*;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import jdk.jpackage.internal.IOUtils.XmlConsumer;

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

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

import static jdk.jpackage.internal.WindowsBundlerParam.MENU_GROUP;

import static jdk.jpackage.internal.WindowsBundlerParam.WINDOWS_INSTALL_DIR;

/**

 * Creates application WiX source files.

 */

class WixSourcesBuilder {

    WixSourcesBuilder setWixVersion(DottedVersion v) {

        wixVersion = v;

        return this;

    }

    WixSourcesBuilder initFromParams(Path appImageRoot,

            Map<String, ? super Object> params) {

        Supplier<ApplicationLayout> appImageSupplier = () -> {

            if (StandardBundlerParam.isRuntimeInstaller(params)) {

                return ApplicationLayout.javaRuntime();

            } else {

                return ApplicationLayout.platformAppImage();

            }

        };

        systemWide = MSI_SYSTEM_WIDE.fetchFrom(params);

        registryKeyPath = Path.of("Software",

                VENDOR.fetchFrom(params),

                APP_NAME.fetchFrom(params),

                VERSION.fetchFrom(params)).toString();

        installDir = (systemWide ? PROGRAM_FILES : LOCAL_PROGRAM_FILES).resolve(

                WINDOWS_INSTALL_DIR.fetchFrom(params));

        do {

            ApplicationLayout layout = appImageSupplier.get();

            // Don't want AppImageFile.FILENAME in installed application.

            // Register it with app image at a role without a match in installed

            // app layout to exclude it from layout transformation.

            layout.pathGroup().setPath(new Object(), Path.of(AppImageFile.FILENAME));

            // Want absolute paths to source files in generated WiX sources.

            // This is to handle scenario if sources would be processed from

            // differnt current directory.

            appImage = layout.resolveAt(appImageRoot.toAbsolutePath().normalize());

        } while (false);

        installedAppImage = appImageSupplier.get().resolveAt(INSTALLDIR);

        shortcutFolders = new HashSet<>();

        if (SHORTCUT_HINT.fetchFrom(params)) {

            shortcutFolders.add(ShortcutsFolder.Desktop);

        }

        if (MENU_HINT.fetchFrom(params)) {

            shortcutFolders.add(ShortcutsFolder.ProgramMenu);

        }

        if (StandardBundlerParam.isRuntimeInstaller(params)) {

            launcherPaths = Collections.emptyList();

        } else {

            launcherPaths = AppImageFile.getLauncherNames(appImageRoot, params).stream()

                    .map(name -> installedAppImage.launchersDirectory().resolve(name))

                    .map(WixSourcesBuilder::addExeSuffixToPath)

                    .collect(Collectors.toList());

        }

        programMenuFolderName = MENU_GROUP.fetchFrom(params);

        initFileAssociations(params);

        return this;

    }

    void createMainFragment(Path file) throws IOException {

        removeFolderItems = new HashMap<>();

        defaultedMimes = new HashSet<>();

        IOUtils.createXml(file, xml -> {

            xml.writeStartElement("Wix");

            xml.writeDefaultNamespace("http://schemas.microsoft.com/wix/2006/wi");

            xml.writeNamespace("util",

                    "http://schemas.microsoft.com/wix/UtilExtension");

            xml.writeStartElement("Fragment");

            addFaComponentGroup(xml);

            addShortcutComponentGroup(xml);

            addFilesComponentGroup(xml);

            xml.writeEndElement();  // <Fragment>

            addIconsFragment(xml);

            xml.writeEndElement(); // <Wix>

        });

    }

    void logWixFeatures() {

        if (wixVersion.compareTo("3.6") >= 0) {

            Log.verbose(I18N.getString("message.use-wix36-features"));

        }

    }

    private void normalizeFileAssociation(FileAssociation fa) {

        fa.launcherPath = addExeSuffixToPath(

                installedAppImage.launchersDirectory().resolve(fa.launcherPath));

        if (fa.iconPath != null && !fa.iconPath.toFile().exists()) {

            fa.iconPath = null;

        }

        // Filter out empty extensions.

        fa.extensions = fa.extensions.stream().filter(Predicate.not(

                String::isEmpty)).collect(Collectors.toList());

    }

    private static Path addExeSuffixToPath(Path path) {

        return IOUtils.addSuffix(path, ".exe");

    }

    private Path getInstalledFaIcoPath(FileAssociation fa) {

        String fname = String.format("fa_%s.ico", String.join("_", fa.extensions));

        return installedAppImage.destktopIntegrationDirectory().resolve(fname);

    }

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

        associations = FileAssociation.fetchFrom(params).stream()

                .peek(this::normalizeFileAssociation)

                // Filter out file associations without extensions.

                .filter(fa -> !fa.extensions.isEmpty())

                .collect(Collectors.toList());

        associations.stream().filter(fa -> fa.iconPath != null).forEach(fa -> {

            // Need to add fa icon in the image.

            Object key = new Object();

            appImage.pathGroup().setPath(key, fa.iconPath);

            installedAppImage.pathGroup().setPath(key, getInstalledFaIcoPath(fa));

        });

    }

    private static UUID createNameUUID(String str) {

        return UUID.nameUUIDFromBytes(str.getBytes(StandardCharsets.UTF_8));

    }

    private static UUID createNameUUID(Path path, String role) {

        if (path.isAbsolute() || !ROOT_DIRS.contains(path.getName(0))) {

            throw throwInvalidPathException(path);

        }

        // Paths are case insensitive on Windows

        String keyPath = path.toString().toLowerCase();

        if (role != null) {

            keyPath = role + "@" + keyPath;

        }

        return createNameUUID(keyPath);

    }

    /**

     * Value for Id attribute of various WiX elements.

     */

    enum Id {

        File,

        Folder("dir"),

        Shortcut,

        ProgId,

        Icon,

        CreateFolder("mkdir"),

        RemoveFolder("rm");

        Id() {

            this.prefix = name().toLowerCase();

        }

        Id(String prefix) {

            this.prefix = prefix;

        }

        String of(Path path) {

            if (this == Folder && KNOWN_DIRS.contains(path)) {

                return path.getFileName().toString();

            }

            String result = of(path, prefix, name());

            if (this == Icon) {

                // Icon id constructed from UUID value is too long and triggers

                // CNDL1000 warning, so use Java hash code instead.

                result = String.format("%s%d", prefix, result.hashCode()).replace(

                        "-", "_");

            }

            return result;

        }

        private static String of(Path path, String prefix, String role) {

            Objects.requireNonNull(role);

            Objects.requireNonNull(prefix);

            return String.format("%s%s", prefix,

                    createNameUUID(path, role).toString().replace("-", ""));

        }

        static String of(Path path, String prefix) {

            return of(path, prefix, prefix);

        }

        private final String prefix;

    }

    enum Component {

        File(cfg().file()),

        Shortcut(cfg().file().withRegistryKeyPath()),

        ProgId(cfg().file().withRegistryKeyPath()),

        CreateFolder(cfg().withRegistryKeyPath()),

        RemoveFolder(cfg().withRegistryKeyPath());

        Component() {

            this.cfg = cfg();

            this.id = Id.valueOf(name());

        }

        Component(Config cfg) {

            this.cfg = cfg;

            this.id = Id.valueOf(name());

        }

        UUID guidOf(Path path) {

            return createNameUUID(path, name());

        }

        String idOf(Path path) {

            return id.of(path);

        }

        boolean isRegistryKeyPath() {

            return cfg.withRegistryKeyPath;

        }

        boolean isFile() {

            return cfg.isFile;

        }

        private static final class Config {

            Config withRegistryKeyPath() {

                withRegistryKeyPath = true;

                return this;

            }

            Config file() {

                isFile = true;

                return this;

            }

            private boolean isFile;

            private boolean withRegistryKeyPath;

        }

        private static Config cfg() {

            return new Config();

        }

        private final Config cfg;

        private final Id id;

    };

    private static void addComponentGroup(XMLStreamWriter xml, String id,

            List<String> componentIds) throws XMLStreamException, IOException {

        xml.writeStartElement("ComponentGroup");

        xml.writeAttribute("Id", id);

        componentIds = componentIds.stream().filter(Objects::nonNull).collect(

                Collectors.toList());

        for (var componentId : componentIds) {

            xml.writeStartElement("ComponentRef");

            xml.writeAttribute("Id", componentId);

            xml.writeEndElement();

        }

        xml.writeEndElement();

    }

    private String addComponent(XMLStreamWriter xml, Path path,

            Component role, XmlConsumer xmlConsumer) throws XMLStreamException,

            IOException {

        final Path directoryRefPath;

        if (role.isFile()) {

            directoryRefPath = path.getParent();

        } else {

            directoryRefPath = path;

        }

        xml.writeStartElement("DirectoryRef");

        xml.writeAttribute("Id", Id.Folder.of(directoryRefPath));

        final String componentId = "c" + role.idOf(path);

        xml.writeStartElement("Component");

        xml.writeAttribute("Id", componentId);

        xml.writeAttribute("Guid", String.format("{%s}", role.guidOf(path)));

        boolean isRegistryKeyPath = !systemWide || role.isRegistryKeyPath();

        if (isRegistryKeyPath) {

            addRegistryKeyPath(xml, directoryRefPath);

            if ((role.isFile() || (role == Component.CreateFolder

                    && !systemWide)) && !SYSTEM_DIRS.contains(directoryRefPath)) {

                xml.writeStartElement("RemoveFolder");

                int counter = Optional.ofNullable(removeFolderItems.get(

                        directoryRefPath)).orElse(Integer.valueOf(0)).intValue() + 1;

                removeFolderItems.put(directoryRefPath, counter);

                xml.writeAttribute("Id", String.format("%s_%d", Id.RemoveFolder.of(

                        directoryRefPath), counter));

                xml.writeAttribute("On", "uninstall");

                xml.writeEndElement();

            }

        }

        xml.writeStartElement(role.name());

        if (role != Component.CreateFolder) {

            xml.writeAttribute("Id", role.idOf(path));

        }

        if (!isRegistryKeyPath) {

            xml.writeAttribute("KeyPath", "yes");

        }

        xmlConsumer.accept(xml);

        xml.writeEndElement();

        xml.writeEndElement(); // <Component>

        xml.writeEndElement(); // <DirectoryRef>

        return componentId;

    }

    private void addFaComponentGroup(XMLStreamWriter xml)

            throws XMLStreamException, IOException {

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

        for (var fa : associations) {

            componentIds.addAll(addFaComponents(xml, fa));

        }

        addComponentGroup(xml, "FileAssociations", componentIds);

    }

    private void addShortcutComponentGroup(XMLStreamWriter xml) throws

            XMLStreamException, IOException {

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

        Set<ShortcutsFolder> defineShortcutFolders = new HashSet<>();

        for (var launcherPath : launcherPaths) {

            for (var folder : shortcutFolders) {

                String componentId = addShortcutComponent(xml, launcherPath,

                        folder);

                if (componentId != null) {

                    defineShortcutFolders.add(folder);

                    componentIds.add(componentId);

                }

            }

        }

        for (var folder : defineShortcutFolders) {

            Path path = folder.getPath(this);

            componentIds.addAll(addRootBranch(xml, path));

            if (!KNOWN_DIRS.contains(path)) {

                componentIds.add(addDirectoryCleaner(xml, path));

            }

        }

        addComponentGroup(xml, "Shortcuts", componentIds);

    }

    private String addShortcutComponent(XMLStreamWriter xml, Path launcherPath,

            ShortcutsFolder folder) throws XMLStreamException, IOException {

        Objects.requireNonNull(folder);

        if (!INSTALLDIR.equals(launcherPath.getName(0))) {

            throw throwInvalidPathException(launcherPath);

        }

        String launcherBasename = IOUtils.replaceSuffix(

                launcherPath.getFileName(), "").toString();

        Path shortcutPath = folder.getPath(this).resolve(launcherBasename);

        return addComponent(xml, shortcutPath, Component.Shortcut, unused -> {

            final Path icoFile = IOUtils.addSuffix(

                    installedAppImage.destktopIntegrationDirectory().resolve(

                            launcherBasename), ".ico");

            xml.writeAttribute("Name", launcherBasename);

            xml.writeAttribute("WorkingDirectory", INSTALLDIR.toString());

            xml.writeAttribute("Advertise", "no");

            xml.writeAttribute("IconIndex", "0");

            xml.writeAttribute("Target", String.format("[#%s]",

                    Component.File.idOf(launcherPath)));

            xml.writeAttribute("Icon", Id.Icon.of(icoFile));

        });

    }

    private List<String> addFaComponents(XMLStreamWriter xml,

            FileAssociation fa) throws XMLStreamException, IOException {

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

        for (var extension: fa.extensions) {

            Path path = INSTALLDIR.resolve(String.format("%s_%s", extension,

                    fa.launcherPath.getFileName()));

            components.add(addComponent(xml, path, Component.ProgId, unused -> {

                xml.writeAttribute("Description", fa.description);

                if (fa.iconPath != null) {

                    xml.writeAttribute("Icon", Id.File.of(getInstalledFaIcoPath(

                            fa)));

                    xml.writeAttribute("IconIndex", "0");

                }

                xml.writeStartElement("Extension");

                xml.writeAttribute("Id", extension);

                xml.writeAttribute("Advertise", "no");

                var mimeIt = fa.mimeTypes.iterator();

                if (mimeIt.hasNext()) {

                    String mime = mimeIt.next();

                    xml.writeAttribute("ContentType", mime);

                    if (!defaultedMimes.contains(mime)) {

                        xml.writeStartElement("MIME");

                        xml.writeAttribute("ContentType", mime);

                        xml.writeAttribute("Default", "yes");

                        xml.writeEndElement();

                        defaultedMimes.add(mime);

                    }

                }

                xml.writeStartElement("Verb");

                xml.writeAttribute("Id", "open");

                xml.writeAttribute("Command", "Open");

                xml.writeAttribute("Argument", "%1");

                xml.writeAttribute("TargetFile", Id.File.of(fa.launcherPath));

                xml.writeEndElement(); // <Verb>

                xml.writeEndElement(); // <Extension>

            }));

        }

        return components;

    }

    private List<String> addRootBranch(XMLStreamWriter xml, Path path)

            throws XMLStreamException, IOException {

        if (!ROOT_DIRS.contains(path.getName(0))) {

            throw throwInvalidPathException(path);

        }

        Function<Path, String> createDirectoryName = dir -> null;

        boolean sysDir = true;

        int levels = 1;

        var dirIt = path.iterator();

        xml.writeStartElement("DirectoryRef");

        xml.writeAttribute("Id", dirIt.next().toString());

        path = path.getName(0);

        while (dirIt.hasNext()) {

            levels++;

            Path name = dirIt.next();

            path = path.resolve(name);

            if (sysDir && !SYSTEM_DIRS.contains(path)) {

                sysDir = false;

                createDirectoryName = dir -> dir.getFileName().toString();

            }

            final String directoryId;

            if (!sysDir && path.equals(installDir)) {

                directoryId = INSTALLDIR.toString();

            } else {

                directoryId = Id.Folder.of(path);

            }

            xml.writeStartElement("Directory");

            xml.writeAttribute("Id", directoryId);

            String directoryName = createDirectoryName.apply(path);

            if (directoryName != null) {

                xml.writeAttribute("Name", directoryName);

            }

        }

        while (0 != levels--) {

            xml.writeEndElement();

        }

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

        while (!SYSTEM_DIRS.contains(path = path.getParent())) {

            componentIds.add(addRemoveDirectoryComponent(xml, path));

        }