#include "core/Scanner.h"
#include <QFile>
#include <dirent.h>
#include <sys/stat.h>
#include <fcntl.h>

namespace whittle {
namespace {

bool statxNoFollow(const QByteArray& path, struct statx& stx) {
    return ::statx(AT_FDCWD, path.constData(), AT_SYMLINK_NOFOLLOW,
                   STATX_TYPE | STATX_MODE | STATX_SIZE |
                   STATX_MTIME | STATX_NLINK, &stx) == 0;
}

std::int64_t mtimeNs(const struct statx& stx) {
    return std::int64_t(stx.stx_mtime.tv_sec) * 1'000'000'000LL
         + stx.stx_mtime.tv_nsec;
}

} 

QHash<QString, FileRecord> Scanner::run(const QStringList& roots,
                                        const QSet<QString>& excluded,
                                        bool isUsb, bool recursive,
                                        const std::atomic<bool>& cancel,
                                        const ProgressFn& onProgress) {
    QHash<QString, FileRecord> out;
    int folders = 0, files = 0;
    qint64 bytes = 0;
    for (const QString& root : roots) {
        if (cancel.load(std::memory_order_relaxed)) break;

        const QString base = isUsb ? root : QString();

        walk(root, base, recursive, excluded, out, folders, files, bytes,
             cancel, onProgress);
    }
    if (onProgress) onProgress(folders, files, bytes);
    return out;
}

void Scanner::walk(const QString& dirPath, const QString& base, bool recursive,
                   const QSet<QString>& excluded,
                   QHash<QString, FileRecord>& out,
                   int& folders, int& files, qint64& bytes,
                   const std::atomic<bool>& cancel, const ProgressFn& onProgress) {
    if (cancel.load(std::memory_order_relaxed)) return;

    const QByteArray dirEnc = QFile::encodeName(dirPath);
    DIR* d = ::opendir(dirEnc.constData());
    if (!d) return;

    if (dirPath != base) {
        struct statx stx;
        if (statxNoFollow(dirEnc, stx) && S_ISDIR(stx.stx_mode)) {
            FileRecord rec;
            rec.absPath = dirPath;
            rec.relPath = dirPath.mid(base.length() + 1);
            rec.isDir   = true;
            rec.mtimeNs = mtimeNs(stx);
            out.insert(rec.relPath, rec);
            if (++folders % 256 == 0 && onProgress) onProgress(folders, files, bytes);
        }
    }

    struct dirent* ent;
    while ((ent = ::readdir(d)) != nullptr) {
        if (cancel.load(std::memory_order_relaxed)) break;
        const char* n = ent->d_name;
        if (n[0] == '.' && (n[1] == '\0' || (n[1] == '.' && n[2] == '\0')))
            continue;

        const QString    childPath = dirPath + '/' + QFile::decodeName(n);
        const QByteArray childEnc  = QFile::encodeName(childPath);

        struct statx stx;
        if (!statxNoFollow(childEnc, stx)) continue;
        const auto mode = stx.stx_mode;

        if (S_ISLNK(mode) || S_ISFIFO(mode) || S_ISSOCK(mode) ||
            S_ISCHR(mode) || S_ISBLK(mode))
            continue;

        if (S_ISDIR(mode)) {
            if (recursive && !excluded.contains(childPath))
                walk(childPath, base, recursive, excluded, out,
                     folders, files, bytes, cancel, onProgress);
        } else if (S_ISREG(mode)) {
            if (stx.stx_nlink > 1) continue;
            FileRecord rec;
            rec.absPath = childPath;
            rec.relPath = childPath.mid(base.length() + 1);
            rec.size    = std::int64_t(stx.stx_size);
            rec.mtimeNs = mtimeNs(stx);
            out.insert(rec.relPath, rec);
            bytes += rec.size;
            if (++files % 256 == 0 && onProgress) onProgress(folders, files, bytes);
        }
    }
    ::closedir(d);
}

}