#include "./mingwbundle.h"
#include "./utilities.h"
#include "./manager.h"
#include "./config.h"

#include <c++utilities/conversion/stringconversion.h>
#include <c++utilities/misc/memory.h>

#include <KTar>
#include <K7Zip>
#include <KZip>

#include <QtConcurrent/QtConcurrent>
#include <QStringBuilder>
#include <QJsonDocument>
#include <QJsonArray>
#include <QFile>

#include <string>
#include <iostream>

using namespace std;
using namespace ApplicationUtilities;

namespace RepoIndex {

using namespace Utilities;

const char *prefix = "mingw-w64-";
size_t prefixLen = 10;

IncludedPackage::IncludedPackage(const Package *package, bool dependencyOnly) :
    package(package),
    dependencyOnly(dependencyOnly)
{}

bool IncludedPackage::operator==(const Package *package) const
{
    return this->package == package;
}

MingwBundle::MingwBundle(Manager &manager, const std::vector<const char *> &packages, const std::vector<const char *> &iconPackages, const std::vector<const char *> &extraPackages, const std::vector<const char *> &qtPlugins) :
    m_manager(manager),
    m_extraPackages(extraPackages),
    m_qtPlugins(qtPlugins)
{
    cerr << shchar << "Resolving dependencies ..." << endl;
    string missing;
    // add mingw-w64 packages
    for(const char *pkgName : packages) {
        if(auto *pkg = manager.packageProviding(Dependency(QString::fromLocal8Bit(strncmp(pkgName, prefix, prefixLen) ? pkgName : (prefix + string(pkgName)).data())))) {
            if(find(m_packages.cbegin(), m_packages.cend(), pkg) == m_packages.cend()) {
                m_packages.emplace_back(pkg, false);
                addDependencies(pkg);
            }
        } else {
            missing.push_back(' ');
            missing.append(pkgName);
        }
    }
    // add additional icon packages
    for(const auto &pkgName : iconPackages) {
        if(auto *pkg = manager.packageProviding(Dependency(QString::fromLocal8Bit(pkgName)))) {
            if(find(m_packages.cbegin(), m_packages.cend(), pkg) == m_packages.cend()) {
                m_packages.emplace_back(pkg, false);
            }
        } else {
            missing.push_back(' ');
            missing.append(pkgName);
        }
    }
    if(!missing.empty()) {
        throw runtime_error("The following packages can not be found:" + missing);
    } else {
        cerr << shchar << "Adding the following packages:";
        for(const IncludedPackage &pkg : m_packages) {
            cerr << shchar << ' ' << pkg.package->name().toLocal8Bit().data();
        }
        cerr << shchar << endl;
    }
}

void MingwBundle::addDependencies(const Package *pkg)
{
    string missing;
    for(const auto &dep : pkg->dependencies()) {
        if(dep.name.startsWith(QLatin1String("mingw-w64-"), Qt::CaseInsensitive)) {
            if(auto *pkg = m_manager.packageProviding(dep)) {
                if(find(m_packages.cbegin(), m_packages.cend(), pkg) == m_packages.cend()) {
                    m_packages.emplace_back(pkg, true);
                    addDependencies(pkg);
                }
            } else {
                missing.push_back(' ');
                missing.append(dep.name.toLocal8Bit());
            }
        }
    }
    if(!missing.empty()) {
        throw runtime_error("The following dependencies of the " + string(pkg->name().toLocal8Bit().data()) + " package can not be resolved:" + missing);
    }
}

enum class RelevantFileType
{
    Binary,
    Data,
    Translation,
    QtTranslation,
    QtPlugin,
    Plugin,
    SharedData,
    GLib2Data,
    GLib2Schemas,
    Theme,
    IconTheme
};

enum class RelevantFileArch
{
    x86_64,
    i686,
    Any
};

struct RelevantFile
{
    RelevantFile(const KArchiveFile *file, const KArchiveDirectory *containingDir, const RelevantFileType type, const RelevantFileArch arch, const QString &subDir = QString()) :
        name(file->name()),
        fileType(type),
        arch(arch),
        subDir(subDir)
    {
        if(file->symLinkTarget().isEmpty()) {
            data = file->data();
        } else if(const auto *targetEntry = containingDir->entry(file->symLinkTarget())) {
            // Windows support for symlinks is not very well
            if(targetEntry->isFile()) {
                data = static_cast<const KArchiveFile *>(targetEntry)->data();
            }
        }
    }

    QString name;
    QByteArray data;
    RelevantFileType fileType;
    RelevantFileArch arch;
    QString subDir;
};

struct PkgFileInfo
{
    PkgFileInfo(const QString &name, const QString &path, bool dependencyOnly = false, const vector<const char *> &qtPlugins = vector<const char *>()) :
        name(name),
        path(path),
        dependencyOnly(dependencyOnly),
        qtPlugins(qtPlugins),
        failure(false)
    {}

    QString name;
    QString path;
    unique_ptr<KTar> archive;
    list<RelevantFile> relevantFiles;
    bool dependencyOnly;
    const vector<const char *> &qtPlugins;
    bool failure;
};

void addEntries(PkgFileInfo &pkgFileInfo, RelevantFileType fileType, const KArchiveDirectory *dir, const QString &relPath = QString(), const QString &ext = QString(), RelevantFileArch relevantArch = RelevantFileArch::Any)
{
    const QString newPath = relPath.isEmpty() ? dir->name() : relPath % QChar('/') % dir->name();
    for(const auto &entryName : dir->entries()) {
        if(auto *entry = dir->entry(entryName)) {
            if(entry->isDirectory()) {
                addEntries(pkgFileInfo, fileType, static_cast<const KArchiveDirectory *>(entry), newPath, ext, relevantArch);
            } else if(entry->isFile()) {
                if(ext.isEmpty() || entry->name().endsWith(ext)) {
                    pkgFileInfo.relevantFiles.emplace_back(static_cast<const KArchiveFile *>(entry), dir, fileType, relevantArch, newPath);
                }
            }
        }
    }
}

void getFiles(PkgFileInfo &pkgFileInfo)
{
    pkgFileInfo.archive = make_unique<KTar>(pkgFileInfo.path);
    if(pkgFileInfo.archive->open(QIODevice::ReadOnly)) {
        static const pair<RelevantFileArch, QString> roots[] = {
            make_pair(RelevantFileArch::x86_64, QStringLiteral("/usr/x86_64-w64-mingw32")),
            make_pair(RelevantFileArch::i686, QStringLiteral("/usr/i686-w64-mingw32"))
        };
        // add files for each architecture separately
        for(const auto &root : roots) {
            // get root entry
            const auto *rootEntry = pkgFileInfo.archive->directory()->entry(root.second);
            if(rootEntry && rootEntry->isDirectory()) {
                const auto *rootDir = static_cast<const KArchiveDirectory *>(rootEntry);

                // binary directory: *.exe and *.dll files required
                const auto *binEntry = rootDir->entry(QStringLiteral("bin"));
                if(binEntry && binEntry->isDirectory()) {
                    const auto *binDir = static_cast<const KArchiveDirectory *>(binEntry);
                    for(const QString &entryName : binDir->entries()) {
                        if((!pkgFileInfo.dependencyOnly && entryName.endsWith(QLatin1String(".exe"))) || entryName.indexOf(QLatin1String(".dll")) > 0) {
                            if(const auto *entry = binDir->entry(entryName)) {
                                // do only copy files and no symlinks
                                if(entry->isFile() && entry->symLinkTarget().isEmpty()) {
                                    pkgFileInfo.relevantFiles.emplace_back(static_cast<const KArchiveFile *>(entry), binDir, RelevantFileType::Binary, root.first);
                                }
                            }
                        }
                    }
                }

                // library directory: Qt, GTK and application specific libs/plugins required
                const auto *libEntry = rootDir->entry(QStringLiteral("lib"));
                if(libEntry && libEntry->isDirectory()) {
                    // Qt 5 plugins
                    const auto *libDir = static_cast<const KArchiveDirectory *>(libEntry);
                    const auto *qtEntry = libDir->entry(QStringLiteral("qt"));
                    if(qtEntry && qtEntry->isDirectory()) {
                        const auto *qtDir = static_cast<const KArchiveDirectory *>(qtEntry);
                        const auto *pluginsEntry = qtDir->entry(QStringLiteral("plugins"));
                        if(pluginsEntry && pluginsEntry->isDirectory()) {
                            const auto *pluginsDir = static_cast<const KArchiveDirectory *>(pluginsEntry);
                            for(const auto &pluginCategory : pluginsDir->entries()) {
                                const auto *categoryEntry = pluginsDir->entry(pluginCategory);
                                if(categoryEntry && categoryEntry->isDirectory()) {
                                    const auto *categoryDir = static_cast<const KArchiveDirectory *>(categoryEntry);
                                    for(const QString &entryName : categoryDir->entries()) {
                                        if(const auto *pluginEntry = categoryDir->entry(entryName)) {
                                            if(pluginEntry->isFile()) {
                                                if(entryName.endsWith(QLatin1String(".dll"))) {
                                                    if(!pkgFileInfo.qtPlugins.empty()) {
                                                        string pluginName = entryName.toLocal8Bit().data();
                                                        pluginName.resize(pluginName.size() - 4);
                                                        if(find(pkgFileInfo.qtPlugins.cbegin(), pkgFileInfo.qtPlugins.cend(), pluginName) == pkgFileInfo.qtPlugins.cend()) {
                                                            continue;
                                                        }
                                                    }
                                                    pkgFileInfo.relevantFiles.emplace_back(static_cast<const KArchiveFile *>(pluginEntry), categoryDir, RelevantFileType::QtPlugin, root.first, categoryDir->name());
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    // Qt 4 plugins
                    qtEntry = libDir->entry(QStringLiteral("qt4"));
                    if(qtEntry && qtEntry->isDirectory()) {
                        addEntries(pkgFileInfo, RelevantFileType::Plugin, static_cast<const KArchiveDirectory *>(qtEntry), QString(), QString(), root.first);
                    }

                    // GTK plugins
                    const auto *gtkEntry = libDir->entry(QStringLiteral("gtk-2.0"));
                    if(gtkEntry && gtkEntry->isDirectory()) {
                        addEntries(pkgFileInfo, RelevantFileType::Plugin, static_cast<const KArchiveDirectory *>(gtkEntry), QString(), QStringLiteral(".dll"), root.first);
                    }
                    gtkEntry = libDir->entry(QStringLiteral("gtk-3.0"));
                    if(gtkEntry && gtkEntry->isDirectory()) {
                        addEntries(pkgFileInfo, RelevantFileType::Plugin, static_cast<const KArchiveDirectory *>(gtkEntry), QString(), QStringLiteral(".dll"), root.first);
                    }

                    // app specific libs/plugins
                    const auto *evinceEntry = libDir->entry(pkgFileInfo.name);
                    if(evinceEntry && evinceEntry->isDirectory()) {
                        addEntries(pkgFileInfo, RelevantFileType::Plugin, static_cast<const KArchiveDirectory *>(evinceEntry), QString(), QStringLiteral(".dll"), root.first);
                        // required by evince
                        addEntries(pkgFileInfo, RelevantFileType::Plugin, static_cast<const KArchiveDirectory *>(evinceEntry), QString(), QStringLiteral(".evince-backend"), root.first);
                    }
                }

                // data directory: required by geany
                const auto *dataEntry = rootDir->entry(QStringLiteral("data"));
                if(dataEntry && dataEntry->isDirectory()) {
                    addEntries(pkgFileInfo, RelevantFileType::Data, static_cast<const KArchiveDirectory *>(dataEntry), QString(), QString(), root.first);
                }

                // share directory: translations, themes, icons, schemas
                const auto *shareEntry = rootDir->entry(QStringLiteral("share"));
                if(shareEntry && shareEntry->isDirectory()) {
                    const auto *shareDir = static_cast<const KArchiveDirectory *>(shareEntry);

                    // Qt translations
                    const auto *qtEntry = shareDir->entry(QStringLiteral("qt"));
                    if(qtEntry && qtEntry->isDirectory()) {
                        const auto *qtDir = static_cast<const KArchiveDirectory *>(qtEntry);
                        const auto *trEntry = qtDir->entry(QStringLiteral("translations"));
                        if(trEntry && trEntry->isDirectory()) {
                            const auto trDir = static_cast<const KArchiveDirectory *>(trEntry);
                            for(const auto &entryName : trDir->entries()) {
                                if(entryName.endsWith(QLatin1String(".qm"))) {
                                    if(const auto *qmEntry = trDir->entry(entryName)) {
                                        if(qmEntry->isFile()) {
                                            pkgFileInfo.relevantFiles.emplace_back(static_cast<const KArchiveFile *>(qmEntry), trDir, RelevantFileType::QtTranslation, root.first);
                                        }
                                    }
                                }
                            }
                        }
                    }

                    // GTK themes
                    const auto *themesEntry = shareDir->entry(QStringLiteral("themes"));
                    if(themesEntry && themesEntry->isDirectory()) {
                        const auto *themesDir = static_cast<const KArchiveDirectory *>(themesEntry);
                        for(const auto &themeName : themesDir->entries()) {
                            const auto *themeEntry = themesDir->entry(themeName);
                            if(themeEntry && themeEntry->isDirectory()) {
                                addEntries(pkgFileInfo, RelevantFileType::Theme, static_cast<const KArchiveDirectory *>(themeEntry), QString(), QString(), root.first);
                            }
                        }
                    }

                    // icon themes
                    const auto *iconsEntry = shareDir->entry(QStringLiteral("icons"));
                    if(iconsEntry && iconsEntry->isDirectory()) {
                        const auto *iconsDir = static_cast<const KArchiveDirectory *>(iconsEntry);
                        for(const auto &themeName : iconsDir->entries()) {
                            const auto *themeEntry = iconsDir->entry(themeName);
                            if(themeEntry && themeEntry->isDirectory()) {
                                addEntries(pkgFileInfo, RelevantFileType::IconTheme, static_cast<const KArchiveDirectory *>(themeEntry), QString(), QString(), root.first);
                            }
                        }
                    }

                    // glib2 stuff (need to compile glib2 schemes later)
                    const auto *glib2Entry = shareDir->entry(QStringLiteral("glib-2.0"));
                    if(glib2Entry && glib2Entry->isDirectory()) {
                        const auto *glib2Dir = static_cast<const KArchiveDirectory *>(glib2Entry);
                        for(const auto &glib2SubEntryName : glib2Dir->entries()) {
                            const auto *glib2SubEntry = glib2Dir->entry(glib2SubEntryName);
                            if(glib2SubEntry->isDirectory()) {
                                if(glib2SubEntry->name() == QLatin1String("schemas")) {
                                    addEntries(pkgFileInfo, RelevantFileType::GLib2Schemas, static_cast<const KArchiveDirectory *>(glib2SubEntry), QStringLiteral("glib-2.0"), QString(), root.first);
                                } else {
                                    addEntries(pkgFileInfo, RelevantFileType::GLib2Data, static_cast<const KArchiveDirectory *>(glib2SubEntry), QStringLiteral("glib-2.0"), QString(), root.first);
                                }
                            } else if(glib2SubEntry->isFile()) {
                                pkgFileInfo.relevantFiles.emplace_back(static_cast<const KArchiveFile *>(glib2SubEntry), glib2Dir, RelevantFileType::GLib2Data, root.first, QStringLiteral("glib-2.0"));
                            }
                        }
                    }

                    // application specific stuff (Qt stuff is added separately, so skip Qt here)
                    if(pkgFileInfo.name.compare(QLatin1String("qt"))) {
                        const auto *appEntry = shareDir->entry(pkgFileInfo.name);
                        if(appEntry && appEntry->isDirectory()) {
                            addEntries(pkgFileInfo, RelevantFileType::SharedData, static_cast<const KArchiveDirectory *>(appEntry), QString(), QString(), root.first);
                        }
                    }

                    const auto *localeEntry = shareDir->entry(QStringLiteral("locale"));
                    if(localeEntry && localeEntry->isDirectory()) {
                        addEntries(pkgFileInfo, RelevantFileType::SharedData, static_cast<const KArchiveDirectory *>(localeEntry), QString(), QString(), root.first);
                    }
                }
            }
        }

        // icons from regular package
        const auto *iconsEntry = pkgFileInfo.archive->directory()->entry(QStringLiteral("usr/share/icons"));
        if(iconsEntry && iconsEntry->isDirectory()) {
            const auto *iconsDir = static_cast<const KArchiveDirectory *>(iconsEntry);
            for(const auto &themeName : iconsDir->entries()) {
                const auto *themeEntry = iconsDir->entry(themeName);
                if(themeEntry && themeEntry->isDirectory()) {
                    addEntries(pkgFileInfo, RelevantFileType::IconTheme, static_cast<const KArchiveDirectory *>(themeEntry));
                }
            }
        }
    } else {
        if(pkgFileInfo.archive->device()) {
            cerr << shchar << "Error: Unable to open the archive " << pkgFileInfo.path.toLocal8Bit().data() << ": " << pkgFileInfo.archive->device()->errorString().toLocal8Bit().data() << endl;
        } else {
            cerr << shchar << "Error: Unable to open the archive " << pkgFileInfo.path.toLocal8Bit().data() << ": Device hasn't been created." << endl;
        }
        pkgFileInfo.failure = true;
    }
}

void makeArchive(const list<PkgFileInfo> &pkgFiles, const QByteArray &pkgList, const QByteArray &indexFile, RelevantFileArch arch, const QString &root, const string &targetDir, const string &targetName, const string &targetFormat)
{
    // prepare archive
    QString targetPath = qstr(targetDir) % QChar('/') % root % QChar('-') % qstr(targetName) % QChar('.') % qstr(targetFormat);
    cerr << shchar << "Making archive \"" << targetPath.toLocal8Bit().data() << "\" ..." << endl;
    unique_ptr<KArchive> targetArchive;
    if(targetFormat == "7z") {
        targetArchive = make_unique<K7Zip>(targetPath);
    } else if(targetFormat == "zip") {
        targetArchive = make_unique<KZip>(targetPath);
    } else if(ConversionUtilities::startsWith<string>(targetFormat, "tar")) {
        targetArchive = make_unique<KTar>(targetPath);
    } else {
        throw runtime_error("Specified archive format \"" + targetFormat + "\" is unknown.");
    }

    // add files to archive
    if(targetArchive->open(QIODevice::WriteOnly)) {
        // -> compile glib2 schemas and add
        vector<const RelevantFile *> glib2SchemaFiles;
        glib2SchemaFiles.reserve(16);
        for(const auto &pkgFile : pkgFiles) {
            for(const RelevantFile &relevantFile : pkgFile.relevantFiles) {
                if(relevantFile.arch == RelevantFileArch::Any || relevantFile.arch == arch) {
                    switch(relevantFile.fileType) {
                    case RelevantFileType::GLib2Schemas:
                        glib2SchemaFiles.push_back(&relevantFile);
                        break;
                    default:
                        ;
                    }
                }
            }
        }
        if(!glib2SchemaFiles.empty()) {
            QTemporaryDir tempDir;
            if(tempDir.isValid()) {
                for(const RelevantFile *schemaFile : glib2SchemaFiles) {
                    QFile file(tempDir.path() % QChar('/') % schemaFile->name);
                    if(!file.open(QFile::WriteOnly) || !file.write(schemaFile->data)) {
                        cerr << shchar << "Unable to create glib2 schema file \"" << schemaFile->name.toLocal8Bit().data() << "\"." << endl;
                    }
                }
                QProcess compiler;
                compiler.setProcessChannelMode(QProcess::ForwardedChannels);
                compiler.start(QStringLiteral("glib-compile-schemas"), QStringList() << tempDir.path());
                compiler.waitForFinished();
                QFile compiledSchemas(tempDir.path() + QStringLiteral("/gschemas.compiled"));
                if(compiledSchemas.open(QFile::ReadOnly)) {
                    targetArchive->writeFile(root + QStringLiteral("/share/glib-2.0/schemas/gschemas.compiled"), compiledSchemas.readAll());
                } else {
                    cerr << shchar << "Unable to compile glib2 schemas: Compiled schemas (gschemas.compiled) not found." << endl;
                }

            } else {
                cerr << shchar << "Unable to compile glib2 schemas: Can't create temp dir." << endl;
            }
        }

        // -> add note
        targetArchive->writeFile(root + QStringLiteral("/note.txt"), QByteArray("This archive has been created with Martchus' repository indexing tool.\n"
                                                                                "List of included packages (name, version, license info and upstream URL): var/lib/repoindex/packages.list\n"
                                                                                "More info: http://martchus.netai.net/page.php?name=programming"));
        // -> add package list
        if(!pkgList.isEmpty()) {
            targetArchive->writeFile(root + QStringLiteral("/var/lib/repoindex/packages.list"), pkgList);
        }
        // -> set default icon theme
        if(!indexFile.isEmpty()) {
            targetArchive->writeFile(root + QStringLiteral("/share/icons/default/index.theme"), indexFile);
        }
        // -> add relevant files from packages
        for(const auto &pkgFile : pkgFiles) {
            for(const RelevantFile &relevantFile : pkgFile.relevantFiles) {
                if(relevantFile.arch == RelevantFileArch::Any || relevantFile.arch == arch) {
                    QString path;
                    mode_t mode;
                    switch(relevantFile.fileType) {
                    case RelevantFileType::Binary:
                        path = root % QStringLiteral("/bin/") % relevantFile.name;
                        mode = 0100755;
                        break;
                    case RelevantFileType::Data:
                        path = root % QStringLiteral("/") % relevantFile.subDir % QChar('/') % relevantFile.name;
                        mode = 0100644;
                        break;
                    case RelevantFileType::Translation:
                        path = root % QStringLiteral("/share/") % pkgFile.name % QStringLiteral("/translations/") % relevantFile.name;
                        mode = 0100644;
                        break;
                    case RelevantFileType::QtTranslation:
                        path = root % QStringLiteral("/share/qt/translations/") % relevantFile.name;
                        mode = 0100644;
                        break;
                    case RelevantFileType::QtPlugin:
                        path = root % QStringLiteral("/bin/") % relevantFile.subDir % QChar('/') % relevantFile.name;
                        mode = 0100755;
                        break;
                    case RelevantFileType::Plugin:
                        path = root % QStringLiteral("/lib/") % relevantFile.subDir % QChar('/') % relevantFile.name;
                        mode = 0100755;
                        break;
                    case RelevantFileType::SharedData:
                    case RelevantFileType::GLib2Data:
                    case RelevantFileType::GLib2Schemas:
                        path = root % QStringLiteral("/share/") % relevantFile.subDir % QChar('/') % relevantFile.name;
                        mode = 0100644;
                        break;
                    case RelevantFileType::Theme:
                        path = root % QStringLiteral("/share/themes/") % relevantFile.subDir % QChar('/') % relevantFile.name;
                        mode = 0100644;
                        break;
                    case RelevantFileType::IconTheme:
                        path = root % QStringLiteral("/share/icons/") % relevantFile.subDir % QChar('/') % relevantFile.name;
                        mode = 0100644;
                        break;
                    }
                    // write the file
                    // disable symlinks: there is no decent support for symlinks under Windows
                    //if(relevantFile.symlinkTarget.isEmpty()) {
                        targetArchive->writeFile(path, relevantFile.data, mode);
                    //} else {
                    //    targetArchive->writeSymLink(path, relevantFile.symlinkTarget, QString(), QString(), mode);
                    //}
                }
            }
        }
    } else if(targetArchive->device()) {
        cerr << shchar << "Error: Unable to open target archive: " << targetArchive->device()->errorString().toLocal8Bit().data() << endl;
    } else {
        cerr << shchar << "Error: Unable to open target archive." << endl;
    }
}

void MingwBundle::createBundle(const string &targetDir, const string &targetName, const string &targetFormat, const string &defaultIconTheme) const
{
    cerr << shchar << "Gathering relevant files ..." << endl;
    // get package files
    list<PkgFileInfo> pkgFiles;
    for(const IncludedPackage &includedPkg : m_packages) {
        const Package *pkg = includedPkg.package;
        QString pkgFile;
        if(!pkg->repository()->packagesDirectory().isEmpty()) {
            pkgFile = pkg->repository()->packagesDirectory() % QChar('/') % pkg->fileName();
        }
        if(pkgFile.isEmpty() || !QFile::exists(pkgFile)) {
            if(!m_manager.pacmanCacheDir().isEmpty()) {
                pkgFile = m_manager.pacmanCacheDir() % QChar('/') % pkg->fileName();
            }
            if(pkgFile.isEmpty() || !QFile::exists(pkgFile)) {
                throw runtime_error("The package file " + string(pkg->fileName().toLocal8Bit().data()) + " can't be found.");
                // TODO: download package from mirror
            }
        }
        // strip "mingw-w64-"-prefix and vcs-suffix (if present)
        QStringRef pkgName = pkg->name().startsWith(QLatin1String("mingw-w64-")) ? pkg->name().midRef(10) : QStringRef(&pkg->name());
        if(pkgName.endsWith(QLatin1String("-svn")) || pkgName.endsWith(QLatin1String("-git"))) {
            pkgName = pkgName.mid(0, pkgName.length() - 4);
        } else if(pkgName.endsWith(QLatin1String("-hg"))) {
            pkgName = pkgName.mid(0, pkgName.length() - 3);
        }
        pkgFiles.emplace_back(pkgName.toString(), pkgFile, includedPkg.dependencyOnly, m_qtPlugins);
    }
    for(const char *pkgFileRawStr : m_extraPackages) {
        QString pkgFile = QString::fromLocal8Bit(pkgFileRawStr);
        if(QFile::exists(pkgFile)) {
            const auto pkg = make_unique<AlpmPackage>(pkgFile); // do not catch the exception here
            pkgFiles.emplace_back(pkg->name().startsWith(QLatin1String("mingw-w64-")) ? pkg->name().mid(10) : pkg->name(), pkgFile, false, m_qtPlugins);
        } else {
            throw runtime_error("The specified extra package \"" + string(pkgFileRawStr) + "\" can't be found.");
        }
    }
    // get relevant files from packages
    QtConcurrent::blockingMap(pkgFiles, getFiles);
    // check whether all packages could be opened
    string failed;
    for(const auto &pkgFile : pkgFiles) {
        if(pkgFile.failure) {
            failed.push_back(' ');
            failed.append(pkgFile.path.toLocal8Bit().data());
        }
    }
    if(!failed.empty()) {
        throw runtime_error("Unable to open the following package files:" + failed);
    }
    // make a list with package info to be included in the target archive
    QJsonArray pkgArray;
    for(const IncludedPackage &pkg : m_packages) {
        pkgArray << pkg.package->simpleInfo();
    }
    QJsonDocument pkgList;
    pkgList.setArray(pkgArray);
    const QByteArray pkgListBytes = pkgList.toJson();
    QByteArray indexFileBytes;
    if(!defaultIconTheme.empty()) {
        indexFileBytes.reserve(23 + defaultIconTheme.size());
        indexFileBytes.append("[Icon Theme]\nInherits=");
        indexFileBytes.append(defaultIconTheme.data());
        indexFileBytes.append('\n');
    }
    // make target archive
    auto run1 = QtConcurrent::run(bind(makeArchive, ref(pkgFiles), ref(pkgListBytes), ref(indexFileBytes), RelevantFileArch::x86_64, QStringLiteral("x86_64-w64-mingw32"), ref(targetDir), ref(targetName), ref(targetFormat)));
    auto run2 = QtConcurrent::run(bind(makeArchive, ref(pkgFiles), ref(pkgListBytes), ref(indexFileBytes), RelevantFileArch::i686, QStringLiteral("i686-w64-mingw32"), ref(targetDir), ref(targetName), ref(targetFormat)));
    run1.waitForFinished();
    run2.waitForFinished();
}

} // namespace PackageManagement