#include "buildarchiveworker.h"
#include "localization.h"

#include <QDir>
#include <QDirIterator>
#include <QFile>
#include <QFileInfo>

#include <algorithm>

#include <QtCore/private/qzipreader_p.h>
#include <QtCore/private/qzipwriter_p.h>

namespace {
bool isSafeRelativePath(const QString &path)
{
    if (path.isEmpty() || path.startsWith(u'/') || path.contains(u'\\') || path.contains(u':'))
        return false;
    const QStringList parts = path.split(u'/');
    for (const QString &part : parts) {
        if (part == QLatin1String(".") || part == QLatin1String(".."))
            return false;
    }
    return true;
}
bool isInside(const QDir &root, const QString &absolutePath)
{
    const QString base = QDir::cleanPath(root.absolutePath()) + u'/';
    return QDir::cleanPath(absolutePath).startsWith(base);
}

QString topSegment(const QString &path)
{
    const int slash = path.indexOf(u'/');
    return slash < 0 ? path : path.left(slash);
}

void pruneEmptyDirs(const QDir &root, QStringList dirs)
{
    std::sort(dirs.begin(), dirs.end(),
              [](const QString &a, const QString &b) { return a.size() > b.size(); });
    for (const QString &relative : std::as_const(dirs)) {
        if (relative.isEmpty() || relative == QLatin1String("."))
            continue;
        QDir dir(root.absoluteFilePath(relative));
        if (dir.exists() && dir.isEmpty())
            root.rmdir(relative);
    }
}

QStringList collectFiles(const QString &gameDir, const QStringList &excludeTop)
{
    QStringList result;
    const QDir root(gameDir);
    const QFileInfoList top = root.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot
                                                 | QDir::Hidden | QDir::System);
    for (const QFileInfo &entry : top) {
        if (excludeTop.contains(entry.fileName()))
            continue;
        if (entry.isSymLink())
            continue;
        if (entry.isFile()) {
            result << entry.fileName();
            continue;
        }
        if (!entry.isDir())
            continue;

        QDirIterator it(entry.absoluteFilePath(),
                        QDir::Files | QDir::Hidden | QDir::System | QDir::NoSymLinks,
                        QDirIterator::Subdirectories);
        while (it.hasNext())
            result << root.relativeFilePath(it.next());
    }
    return result;
}

}

BuildArchiveWorker::BuildArchiveWorker(QObject *parent)
    : QObject(parent)
{
}

void BuildArchiveWorker::archive(const QString &gameDir,
                                 const QString &tempZipPath,
                                 const QStringList &excludeTop)
{
    const QDir root(gameDir);
    if (!root.exists()) {
        emit finished(false, Loc::text("switch.error.gameDirMissing").arg(QDir::toNativeSeparators(gameDir)));
        return;
    }

    const QStringList files = collectFiles(gameDir, excludeTop);
    emit progress(0, files.size(), {});

    {
        QZipWriter writer(tempZipPath);
        if (writer.status() != QZipWriter::NoError) {
            emit finished(false,
                          Loc::text("switch.error.archiveCreateFailed")
                              .arg(QDir::toNativeSeparators(tempZipPath)));
            return;
        }
        writer.setCompressionPolicy(QZipWriter::AutoCompress);

        int done = 0;
        for (const QString &relative : files) {
            if (canceled()) {
                writer.close();
                QFile::remove(tempZipPath);
                emit finished(false, Loc::text("switch.status.archivingCancelled"));
                return;
            }

            QFile file(root.absoluteFilePath(relative));
            if (!file.open(QIODevice::ReadOnly)) {
                writer.close();
                QFile::remove(tempZipPath);
                emit finished(false,
                              Loc::text("common.error.readFailed")
                                  .arg(QDir::toNativeSeparators(relative), file.errorString()));
                return;
            }
            writer.addFile(relative, &file);
            file.close();

            if (writer.status() != QZipWriter::NoError) {
                writer.close();
                QFile::remove(tempZipPath);
                emit finished(false,
                              Loc::text("switch.error.archiveWriteFailed")
                                  .arg(QDir::toNativeSeparators(relative)));
                return;
            }
            emit progress(++done, files.size(), relative);
        }
        writer.close();
    }

    emit finished(true, {});
}

void BuildArchiveWorker::clear(const QString &gameDir, const QStringList &keepTop)
{
    QDir root(gameDir);
    if (!root.exists()) {
        emit finished(true, {});
        return;
    }

    QFileInfoList victims;
    const QFileInfoList top = root.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot
                                                 | QDir::Hidden | QDir::System);
    for (const QFileInfo &entry : top) {
        if (!keepTop.contains(entry.fileName()))
            victims << entry;
    }

    emit progress(0, victims.size(), {});
    int done = 0;
    for (const QFileInfo &entry : victims) {
        const bool ok = entry.isDir() && !entry.isSymLink()
                            ? QDir(entry.absoluteFilePath()).removeRecursively()
                            : QFile::remove(entry.absoluteFilePath());
        if (!ok) {
            emit finished(false,
                          Loc::text("switch.error.removeFailed")
                              .arg(QDir::toNativeSeparators(entry.absoluteFilePath())));
            return;
        }
        emit progress(++done, victims.size(), entry.fileName());
    }

    emit finished(true, {});
}

void BuildArchiveWorker::restore(const QString &zipPath, const QString &gameDir)
{
    QZipReader reader(zipPath);
    if (!reader.isReadable()) {
        emit finished(false,
                      Loc::text("switch.error.archiveOpenFailed").arg(QDir::toNativeSeparators(zipPath)));
        return;
    }

    const QList<QZipReader::FileInfo> entries = reader.fileInfoList();
    emit progress(0, entries.size(), {});

    const QDir root(gameDir);
    if (!QDir().mkpath(gameDir)) {
        emit finished(false,
                      Loc::text("common.error.createFailed").arg(QDir::toNativeSeparators(gameDir)));
        return;
    }

    int done = 0;
    for (const QZipReader::FileInfo &entry : entries) {
        if (canceled()) {
            emit finished(false, Loc::text("switch.status.extractCancelled"));
            return;
        }
        if (!entry.isFile) {
            emit progress(++done, entries.size(), entry.filePath);
            continue;
        }
        if (!isSafeRelativePath(entry.filePath)) {
            emit finished(false,
                          Loc::text("switch.error.archiveBadPath").arg(entry.filePath));
            return;
        }

        const QString target = root.absoluteFilePath(entry.filePath);
        if (!QDir().mkpath(QFileInfo(target).absolutePath())) {
            emit finished(false,
                          Loc::text("common.error.createFailed")
                              .arg(QDir::toNativeSeparators(QFileInfo(target).absolutePath())));
            return;
        }

        QFile file(target);
        const QByteArray data = reader.fileData(entry.filePath);
        if (!file.open(QIODevice::WriteOnly) || file.write(data) != data.size()) {
            emit finished(false,
                          Loc::text("switch.error.writeFailed")
                              .arg(QDir::toNativeSeparators(entry.filePath), file.errorString()));
            return;
        }
        file.close();
        emit progress(++done, entries.size(), entry.filePath);
    }

    emit finished(true, {});
}

void BuildArchiveWorker::applyPack(const QString &zipPath,
                                   const QString &gameDir,
                                   const QStringList &removeRelative,
                                   const QStringList &forbiddenTop)
{
    QZipReader reader(zipPath);
    if (!reader.isReadable()) {
        emit finished(false,
                      Loc::text("switch.error.archiveOpenFailed").arg(QDir::toNativeSeparators(zipPath)));
        return;
    }
    const QList<QZipReader::FileInfo> entries = reader.fileInfoList();
    QStringList applied;
    applied.reserve(entries.size());
    for (const QZipReader::FileInfo &entry : entries) {
        if (!entry.isFile)
            continue;
        if (!isSafeRelativePath(entry.filePath)) {
            emit finished(false,
                          Loc::text("switch.error.packBadPath").arg(entry.filePath));
            return;
        }
        if (forbiddenTop.contains(topSegment(entry.filePath))) {
            emit finished(false,
                          Loc::text("switch.error.packTouchesLauncher")
                              .arg(entry.filePath));
            return;
        }
        applied << entry.filePath;
    }

    const QDir root(gameDir);
    if (!QDir().mkpath(gameDir)) {
        emit finished(false, Loc::text("common.error.createFailed").arg(QDir::toNativeSeparators(gameDir)));
        return;
    }

    const int total = removeRelative.size() + applied.size();
    emit progress(0, total, {});
    int done = 0;
    QStringList touchedDirs;
    for (const QString &relative : removeRelative) {
        if (canceled()) {
            emit finished(false, Loc::text("switch.status.installCancelled"));
            return;
        }
        if (!isSafeRelativePath(relative) || forbiddenTop.contains(topSegment(relative))) {
            emit progress(++done, total, relative);
            continue;
        }
        const QString target = root.absoluteFilePath(relative);
        if (!isInside(root, target)) {
            emit progress(++done, total, relative);
            continue;
        }
        if (QFileInfo::exists(target) && !QFile::remove(target)) {
            emit finished(false,
                          Loc::text("switch.error.removeFailed").arg(QDir::toNativeSeparators(target)));
            return;
        }
        const QString parent = QFileInfo(relative).path();
        if (!touchedDirs.contains(parent))
            touchedDirs << parent;
        emit progress(++done, total, relative);
    }
    pruneEmptyDirs(root, touchedDirs);
    for (const QString &relative : std::as_const(applied)) {
        if (canceled()) {
            emit finished(false, Loc::text("switch.status.installCancelled"));
            return;
        }

        const QString target = root.absoluteFilePath(relative);
        if (!isInside(root, target)) {
            emit finished(false,
                          Loc::text("switch.error.packEscapesGameDir")
                              .arg(relative));
            return;
        }
        if (!QDir().mkpath(QFileInfo(target).absolutePath())) {
            emit finished(false,
                          Loc::text("common.error.createFailed")
                              .arg(QDir::toNativeSeparators(QFileInfo(target).absolutePath())));
            return;
        }

        QFile file(target);
        const QByteArray data = reader.fileData(relative);
        if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)
            || file.write(data) != data.size()) {
            emit finished(false,
                          Loc::text("switch.error.writeFailed")
                              .arg(QDir::toNativeSeparators(relative), file.errorString()));
            return;
        }
        file.close();
        emit progress(++done, total, relative);
    }

    emit packEntries(applied);
    emit finished(true, {});
}