controller.cpp

#include "controller.h"

#include <QFile>
#include <QFileInfo>
#include <QDir>
#include <QDirIterator>
#include <QListIterator>
#include <QList>
#include <QString>
#include <QStringList>
#include <QTreeWidgetItem>
#include <QDateTime>
#include <QSize>
#include <QImage>
#include <QIODevice>
#include <QTextStream>
#include <QRegularExpression>
#include <QObject>
#include <QImageWriter>
#include <QNetworkRequest>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QJsonDocument>
#include <QJsonArray>
#include <QSettings>
#include <QRect>
//#include <QDesktopWidget>
#include <QScreen>
#include <QApplication>
#include <QtMath>
#include <QVersionNumber>
#include <QDebug>
#include <QtGlobal>
#include <QtDebug>
#include <QLocale>
#include <QTime>
#include <QPixmap>
#include <QUrlQuery>
#include <QStandardPaths>
#include "aes.hpp" // Tiny-AES



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


void Controller::bootStrap()
{
    if ( (os == "Linux") || (os == "macOS") ) {
        isUnixLikeOS = true;
        if ( os == "Linux" ) {
            settings = new QSettings(QSettings::NativeFormat, QSettings::UserScope, "Alsweider", "SteaScreeLoaded");
            defaultSteamDir = QDir::homePath() + "/.steam/steam";
        } else {
            settings = new QSettings(QSettings::NativeFormat, QSettings::UserScope, "Alsweider", "SteaScreeLoaded");
            defaultSteamDir = QDir::homePath() + "/Library/Application Support/Steam";
        }
    } else {
        isUnixLikeOS = false;
        settings = new QSettings(QSettings::IniFormat, QSettings::UserScope, "Alsweider", "SteaScreeLoaded");
        if ( QSysInfo::currentCpuArchitecture() == "x86_64" )
            defaultSteamDir = "C:/Program Files (x86)/Steam";
        else
            defaultSteamDir = "C:/Program Files/Steam";
    }

    readSettings(); // read settings from the file, if any

    if (offerUpdateSetting != "Never"){ // Kein Update, wenn Benutzer Never festgelegt hat
        if (apiIndex != 2){ // Kein automatisches Update im Offline-Modus
            checkForUpdates();
        }
    }

    if (!screenshotPathsPool.isEmpty()) {
        populateScreenshotQueue(screenshotPathsPool);
        emit sendWidgetsDisabled(QStringList() << "pushButton_clearQueue" << "pushButton_copyScreenshots", false);
    }

    if ( !steamDir.isNull() ) {
        userDataDir = steamDir + "/userdata";
        setUserDataPaths(steamDir);
    }





}


void Controller::readSettings()
{
    settings->beginGroup("WindowGeometry");
    //QRect rec = QApplication::desktop()->availableGeometry(); //veraltet
    QRect rec = QGuiApplication::primaryScreen()->availableGeometry();
    QSize geometry = settings->value("Size", QSize(685, 450)).toSize();
    QPoint moveToPoint = settings->value("Position", QPoint((rec.width()-685)/2, (rec.height()-450)/2)).toPoint();
    emit moveWindow(geometry, moveToPoint);
    settings->endGroup();

    settings->beginGroup("LastSelection");
    steamDir = settings->value("SteamDir", defaultSteamDir).toString();

    if (QDir(steamDir).exists())
        emit sendLabelsText(QStringList() << "label_steamDirValue", convertSlashes(steamDir));
    else
        emit sendLabelsText(QStringList() << "label_steamDirValue", "Not found, please locate manually");

    lastSelectedScreenshotDir = settings->value("Screenshots", QDir::currentPath()).toString();
    lastSelectedUserID = settings->value("UserID").toString();
    lastSelectedGameID = settings->value("GameID").toString();

    // apiKey = settings->value("ApiKey").toString();

    // API-Key entschlüsseln
    QString storedApiKey = settings->value("ApiKey").toString();
    qDebug() << "Verschlüsselter apiKey: " << storedApiKey;
    if (!storedApiKey.isEmpty()){
        // Prüfen, ob es nach Base64 aussieht
        QRegularExpression base64Regex("^[A-Za-z0-9+/=]+$");
        if (base64Regex.match(storedApiKey).hasMatch() && storedApiKey.length() > 32) {
            // Vermutlich verschlüsselt
            apiKey = decryptAPIKey(storedApiKey);
            qDebug() << "API-Key entschlüsselt:" << apiKey;
        } else {
            // Klartext-Key aus älterer Version
            apiKey = storedApiKey;
            qDebug() << "Klartext-API-Key gefunden:" << apiKey;
            // Sofort verschlüsselt speichern, um Migration abzuschließen
            settings->setValue("ApiKey", encryptAPIKey(apiKey));
        }
        // qDebug() << "apiKey entschlüsselt: " << apiKey;
    }
    else {
        apiKey.clear();
        qDebug() << "Kein API-Key vorhanden.";
    }
    // int apiIndex = settings->value("ChosenAPIIndex", 0).toInt();
    // Prüfen, ob ein API-Index bereits gespeichert ist
    QVariant savedIndex = settings->value("ChosenAPIIndex");

    if (savedIndex.isValid()) {
        apiIndex = savedIndex.toInt(); // bisherige Auswahl laden
    } else {
        apiIndex = 3; // Lokale games.json bzw. Download von Mirror. Aktuell zuverlässigste und schnellste Methode.
    }
    emit sendApiIndex(apiIndex);
    qDebug() << "Einstellung API comboBox Index geladen: " << apiIndex;

    quint32 jpegQuality = settings->value("JPEGQuality").toInt();
    if (jpegQuality < 1 || jpegQuality > 100)
        jpegQuality = defaultJpegQuality;
    emit sendJpegQualityValue(jpegQuality);
    settings->endGroup();

    //letzte Position der comboBoxAPI laden
    emit sendIndexOfComboBoxAPI("comboBox_chooseAPI", apiIndex);

    //Wenn API-Key vorhanden ist, true
    bool keyExists = !apiKey.isEmpty();
    emit sendApiKeyState(keyExists);

    settings->beginGroup("Screenshots");
    screenshotPathsPool = settings->value("Queue").toStringList();
    settings->endGroup();

    settings->beginGroup("Update");
    offerUpdateSetting = settings->value("Offer").toString();
    settings->endGroup();

    settings->beginGroup("WindowPreferences");
    footerVisible = settings->value("footer", true).toBool(); // Standard: true
    settings->endGroup();

    emit loadFooterState(footerVisible);

}


void Controller::writeSettings(QSize size, QPoint pos, QString userID, QString gameID, quint32 jpegQuality, int apiIndex)
{
    settings->beginGroup("WindowGeometry");
    settings->setValue("Size", size);
    settings->setValue("Position", pos);
    settings->endGroup();

    settings->beginGroup("LastSelection");
    settings->setValue("SteamDir", steamDir.replace("\\", "/"));
    settings->setValue("Screenshots", lastSelectedScreenshotDir.replace("\\", "/"));
    if ( !userID.isEmpty() )
        settings->setValue("UserID", userID);
    if ( !gameID.isEmpty() )
        settings->setValue("GameID", gameID);
    settings->setValue("JPEGQuality", jpegQuality);

    // settings->setValue("ApiKey", apiKey);

    // API-Key verschlüsseln
    if (!apiKey.isEmpty())
        settings->setValue("ApiKey", encryptAPIKey(apiKey));

    settings->setValue("ChosenAPIIndex", apiIndex);
    settings->endGroup();

    settings->beginGroup("Screenshots");
    settings->setValue("Queue", screenshotPathsPool);
    settings->endGroup();

    settings->beginGroup("WindowPreferences");
    settings->setValue("footer", footerVisible);
    settings->endGroup();
}


void Controller::checkForUpdates()
{
    qDebug() << "checkForUpdates() aufgerufen";
    QNetworkAccessManager *nam = new QNetworkAccessManager(this);

    // Header setzen, GitHub API verlangt User-Agent
    QNetworkRequest request(QUrl("https://api.github.com/repos/Alsweider/SteaScreeLoaded/releases/latest"));
    request.setRawHeader("User-Agent", "SteaScreeLoaded");

    QObject::connect(nam, &QNetworkAccessManager::finished,
                     this, &Controller::handleUpdate);
    nam->get(request);
}


void Controller::handleUpdate(QNetworkReply *reply)
{
    qDebug() << "handleUpdate() aufgerufen";
    if (reply->error() == QNetworkReply::NoError) {
        QByteArray raw = reply->readAll();
        QJsonDocument doc(QJsonDocument::fromJson(raw));
        QJsonObject obj = doc.object();

        // Version aus tag_name lesen (GitHub Releases)
        QString latestVersion = obj.value("tag_name").toString();
        if (latestVersion.startsWith('v', Qt::CaseInsensitive)) {
            latestVersion.remove(0, 1); // entfernt das erste Zeichen 'v'

            qDebug() << "latestVersion GitHub: " << latestVersion;
            QString versionInfo("Latest version: " + latestVersion);
            emit updateStatusMessage(versionInfo);
        }

        QString appVersion = QCoreApplication::applicationVersion();
        QVersionNumber appVersionNumber = QVersionNumber::fromString(appVersion);
        QVersionNumber latestVersionNumber = QVersionNumber::fromString(latestVersion);

        if (QVersionNumber::compare(latestVersionNumber, appVersionNumber) > 0) {
            QString link;

            // Zuerst die Assets prüfen
            QJsonArray assets = obj.value("assets").toArray();
            if (!assets.isEmpty()) {
                link = assets.at(0).toObject().value("browser_download_url").toString();
            }

            // Falls keine Assets vorhanden, auf zipball_url zurückgreifen
            if (link.isEmpty()) {
                link = obj.value("zipball_url").toString();
            }

            qDebug() << "Update verfügbar:" << latestVersion << ", Link:" << link;
            QString updateMessage("Update available: " + latestVersion);
            emit updateStatusMessage(updateMessage);

            emit sendUpdateInfo(latestVersion, link);
        }
    } else {
        QString error = reply->errorString();
        qDebug() << "Update check failed:" << error;
        emit updateStatusMessage("Update check failed: " + error);
    }

}


void Controller::writeSettingNeverOfferUpdate()
{
    settings->beginGroup("Update");
    settings->setValue("Offer", "Never");
    settings->endGroup();
}


void Controller::setUserDataPaths(QString dir)  // function to validate and set data paths and IDs
{
    userDataDir = dir + "/userdata";

    QStringList userIDsCombined;

    vdfPaths.clear();                           // there may be multiple Steam installations in the system and thus multiple VDFs
    userID.clear();
    someID.clear();

    emit sendComboBoxesCleared( QStringList() << "comboBox_userID" << "comboBox_gameID");

    QStringList widgetList;
    widgetList << "label_userID" << "comboBox_userID" << "label_gameID" << "comboBox_gameID" << "groupBox_screenshotQueue";

    emit sendWidgetsDisabled(widgetList, true);

    if ( QDir(dir + "/userdata").exists() ) {

        QDirIterator i(userDataDir, QStringList() << vdfFilename, QDir::Files, QDirIterator::Subdirectories);
        while ( i.hasNext() ) {
            vdfPaths << i.next();
        }

        if ( !vdfPaths.isEmpty() ) {

            emit sendWidgetsDisabled(widgetList << "groupBox_screenshotQueue" << "treeWidget_screenshotList", false);
            emit sendLabelsText(QStringList() << "label_steamDirValue", convertSlashes(dir));

            steamDir = dir;

            QStringList userIDsCombinedWithNames;
            QListIterator<QString> i(vdfPaths);
            while ( i.hasNext() ) {
                QString current = i.next();

                QStringList splitted = current.split('/');

                userID = splitted.takeAt(splitted.length() - 3);

                someID = splitted.takeAt(splitted.length() - 2);

                userIDsCombined << userID + "/" + someID;

                QString personalName = getPersonalNameByUserID(userID);

                userIDsCombinedWithNames << userID + "/" + someID + personalName;
            }

            if (!lastSelectedUserID.isEmpty()) {
                userID = lastSelectedUserID;
            } else {
                userID = userIDsCombined[0];
            }

            QStringList items;
            if ( isUnixLikeOS )
                items = userIDsCombinedWithNames;
            else {
                items = userIDsCombinedWithNames.replaceInStrings("/", "\\");
                userID = userID.replace("/", "\\");
            }

            selectedUserID = userID;

            emit sendToComboBox("comboBox_userID", items);

            emit sendIndexOfComboBox("comboBox_userID", userID);


            emit sendStatusLabelText("ready", "");
            emit sendLabelsVisible(QStringList() << "label_status", true);

            //Spiel-IDs schon mal einfüllen
            fillGameIDs(userID);

            // Abbruch, wenn kein API-Key gespeichert ist, aber die gewählte API einen verlangt
            if (apiIndex == 1 && apiKey.isEmpty()) {
              //  emit sendStatusLabelText("error", "API Key missing for API 1");
                emit sendStatusLabelText("API Key missing for Old Steam API (V1)", warningColor);
                emit sendToComboBox("comboBox_gameID", QStringList() << "Add API key below / choose different source");

                return;
            }

            emit sendToComboBox("comboBox_gameID", QStringList() << "loading...");

            QNetworkAccessManager *nam = new QNetworkAccessManager(this);

            if (apiIndex == 1) {
                qDebug() << "Alte API V1 gewählt, API-Key (entschlüsselt): " << apiKey;

                    // http://api.steampowered.com/<interface name>/<method name>/v<version>/?key=<api key>&format=<format>
                    QUrl url("https://api.steampowered.com/IStoreService/GetAppList/v1");
                    QUrlQuery query;
                    query.addQueryItem("key", apiKey);
                    query.addQueryItem("format", "json");
                    query.addQueryItem("max_results", "9999999");
                    query.addQueryItem("last_appid", "0");
                    url.setQuery(query);

                    checkApiReachability(url);

                    // Um Verbindungsfehler auszulesen
                    QNetworkReply *reply = nam->get(QNetworkRequest(url));

                    QObject::connect(reply, &QNetworkReply::finished, this, [=]() {
                        getGameNamesV1(reply);
                    });

                    // Verbindungsfehler lesen
                    QObject::connect(reply, &QNetworkReply::errorOccurred, this,
                                     [=](QNetworkReply::NetworkError code){
                                         qDebug() << "Fehler:" << code << reply->errorString();
                                     });


                    // QObject::connect(nam, &QNetworkAccessManager::finished,
                    //                  this, &Controller::getGameNamesV1);

                    // nam->get(QNetworkRequest(url));
            } else if (apiIndex == 0){
                    // Ohne API-Key: V2-Endpoint
                    qDebug() << "Neue API V2 gewählt (V2, kein Key nötig, aber evtl. inaktiv)";
                    QUrl url("https://api.steampowered.com/ISteamApps/GetAppList/v2"); // Adresse der aktuell inaktiven API V2

                    checkApiReachability(url);

                    // Um Verbindungsfehler auszulesen
                    QNetworkReply *reply = nam->get(QNetworkRequest(url));

                    QObject::connect(reply, &QNetworkReply::finished, this, [=]() {
                        getGameNamesV2(reply);
                    });

                    // Verbindungsfehler lesen
                    QObject::connect(reply, &QNetworkReply::errorOccurred, this,
                                     [=](QNetworkReply::NetworkError code){
                                         qDebug() << "Fehler:" << code << reply->errorString();
                                     });


                    // QObject::connect(nam, &QNetworkAccessManager::finished,
                    //                  this, &Controller::getGameNamesV2);

                    // nam->get(QNetworkRequest(url));
            } else if (apiIndex == 2){ //Keine externen API-Anfragen //  (apiIndex == 2)
                qDebug() << "Index " << apiIndex << ". Keine API-Anfragen, nur lokale Informationen nutzen";

                QByteArray localJson = loadJsonLocal().toUtf8();
                if (!localJson.isEmpty()) {
                    parseJson(localJson);
                } else {
                    fillGameIDs(userID);
                }

            } else if (apiIndex == 3) {
                // JSON laden
                qDebug() << "API = JSON local/mirror";

                QUrl url("https://raw.githubusercontent.com/Alsweider/SteaScreeLoaded/refs/heads/master/games.json");
                checkApiReachability(url);

                QByteArray localJson = loadJsonLocal().toUtf8();
                if (!localJson.isEmpty()) {
                    parseJson(localJson);
                } else {
                    emit sendToComboBox("comboBox_gameID", QStringList() << "Downloading JSON...");
                    loadJsonFromGithub();
                }
            } else {
                qDebug() << "Index " << apiIndex << ". Falscher Index?";
                fillGameIDs(userID);
            }

        } else {
            emit sendLabelsOnMissingStuff(false, vdfFilename);
        }

    } else {
        emit sendLabelsOnMissingStuff(true, vdfFilename);
    }
}


QString Controller::getPersonalNameByUserID(QString userID)
{
    // Neue Methode: localconfig.vdf
    QString localConfigPath = userDataDir + "/" + userID + "/config/localconfig.vdf";
    QFile file(localConfigPath);

    if (file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        QString content = QString::fromUtf8(file.readAll());
        file.close();

        QRegularExpression re("\"PersonaName\"\\s*\"([^\"]+)\"");
        QRegularExpressionMatch match = re.match(content);
        if (match.hasMatch()){
            qDebug() << "Name gefunden, neue Methode: " << match.captured(1) << Qt::endl;
            return " <" + match.captured(1) + ">"; // Gefundener Profilname
        }
    }

    // Fallback: Alte Methode
    QStringList configFiles;
    QDirIterator it(userDataDir + "/" + userID, QStringList() << "config.cfg", QDir::Files, QDirIterator::Subdirectories);
    while (it.hasNext()) {
        configFiles << it.next();
    }

    QListIterator<QString> i(configFiles);
    while (i.hasNext()) {
        QString current = i.next();
        QFile vdf(current);
        if (!vdf.open(QIODevice::ReadOnly | QIODevice::Text))
            continue;

        QTextStream text(&vdf);
        QStringList lines;
        while (!text.atEnd()) {
            lines << text.readLine();
        }
        vdf.close();

        QRegularExpression reOld("^name \"(?<name>.+)\"$");
        int pos = lines.indexOf(reOld);
        QRegularExpressionMatch matchOld;

        if (pos != -1 && lines[pos].contains(reOld, &matchOld)) {
            qDebug() << "Name gefunden, alte Methode: " << matchOld.captured("name") << Qt::endl;
            return " <" + matchOld.captured("name") + ">";
        }
    }

    // Wenn nichts gefunden wurde
    return QString();
}

//GetAppList/v1
void Controller::getGameNamesV1(QNetworkReply *reply)
{
    //     if (games.isEmpty()) {

        if (reply->error() == QNetworkReply::NoError) {

            QByteArray raw = reply->readAll();
            QJsonDocument doc = QJsonDocument::fromJson(raw);

            QJsonArray apps = doc.object().value("response").toObject().value("apps").toArray();

            for (int i = 0; i < apps.size(); ++i) {
                QJsonObject obj = apps[i].toObject();
                QString appID = QString::number(static_cast<quint32>(obj.value("appid").toDouble()));
                QString name = obj.value("name").toString();
                games[appID] = name;
            }
        }
 //   }

    fillGameIDs(userID);
}



//GetAppList/v2
void Controller::getGameNamesV2(QNetworkReply *reply)
{
  //  if ( games.isEmpty() ) {

        if ( reply->error() == QNetworkReply::NoError ) {

            QByteArray raw = reply->readAll();
            QJsonDocument doc(QJsonDocument::fromJson(raw));
            QJsonArray apps = doc.object().value("applist").toObject().value("apps").toArray();

            for (int i = 0; i < apps.size(); ++i) {
                QJsonObject obj = apps[i].toObject();
                QString appID = QString::number(static_cast<quint32>(obj.value("appid").toDouble()));
                QString name = obj.value("name").toString();
                games[appID] = name;
            }

        }
 //   }

    fillGameIDs(userID);
}


void Controller::fillGameIDs(QString userIDCombined)
{
    getShortcutNames();
    QStringList gameIDs;

    QDirIterator i(userDataDir + "/" + userIDCombined + "/" + "/remote", QDir::Dirs | QDir::NoDotAndDotDot);
    while ( i.hasNext() ) {

        QString gameID = i.next().section('/', -1);

        if ( !games[gameID].isEmpty() )
            gameIDs << gameID + " <" + games[gameID] + ">";
        else
            gameIDs << gameID;
    }

    if (games.isEmpty()) {
        // keine Namen vorhanden
        // => IDs ohne Namen eintragen
        emit sendComboBoxesCleared(QStringList() << "comboBox_gameID");
        emit sendToComboBox("comboBox_gameID", gameIDs); // ID-only
        return;
    }

    emit sendComboBoxesCleared(QStringList() << "comboBox_gameID");

    if ( !gameIDs.isEmpty() )
        emit sendToComboBox("comboBox_gameID", gameIDs);

    if ( !lastSelectedGameID.isEmpty() )
        emit sendIndexOfComboBox("comboBox_gameID", lastSelectedGameID);

    emit sendWidgetsDisabled(QStringList() << "pushButton_addScreenshots", false);

    emit sendStatusLabelText("ready", "");
    emit sendLabelsVisible(QStringList() << "label_status", true);
}


void Controller::getShortcutNames()
{
    QStringList lines = readVDF();
    qint32 shortcutNamesHeaderPos = lines.indexOf("\t\"shortcutnames\"");       // if there are any non-Steam games, get names for them too, from the VDF
    qint32 shortcutNamesEndPos = lines.indexOf("\t}", shortcutNamesHeaderPos);
    QStringList shortcutNamesSection = lines.mid(shortcutNamesHeaderPos, shortcutNamesEndPos - shortcutNamesHeaderPos);
    QRegularExpression re("^\t\t\"[0-9]+\"\t\t\".+\"$");

    if ( shortcutNamesSection.indexOf(re) != -1 ) {

        qint32 entryPos = 0;

        while ( (entryPos <= shortcutNamesSection.length() - 1) && (entryPos != -1) ) {

            entryPos = shortcutNamesSection.indexOf(re, entryPos + 1);

            if ( entryPos != -1 ) {
                QString gameID = shortcutNamesSection[entryPos].section("\t\t", 1, 1).remove(QRegularExpression("(^\")|(\"$)"));
                QString gameName = shortcutNamesSection[entryPos].section("\t\t", 2, 2).remove(QRegularExpression("(^\")|(\"$)"));
                games[gameID] = gameName;
            }
        }
    }
}


void Controller::populateScreenshotQueue(QStringList screenshotPathsList) // function to populate screenshot queue with entries
{
    if ( !screenshotPathsList.isEmpty() ) {

        QTreeWidgetItem *item = NULL;
        QListIterator<QString> i(screenshotPathsList);
        while ( i.hasNext() ) {
            QString current = i.next();
            if ( QFile(current).exists() ) {
                item = new QTreeWidgetItem;
                item->setText(0, current.section('/', -1));
                item->setText(1, QFileInfo(QFile(current)).lastModified().toString("yyyy/MM/dd hh:mm:ss"));
                QString path;
                path = convertSlashes(current.section('/', 0, -2));
                item->setText(2, path);
                emit addWidgetItemToScreenshotList(item);
            } else
                screenshotPathsPool.removeOne(current);
        }

        emit resizeScreenshotListColumns();
    }
}


void Controller::addScreenshotsToPool(QStringList screenshotsSelected)
{
    QListIterator<QString> i(screenshotsSelected);
    while ( i.hasNext() ) {

        QString current = i.next();
        QString extension = current.section('.', -1).toLower();

        if ( screenshotPathsPool.contains(current) || !imageFormatsSupported.contains(extension) )
            screenshotsSelected.removeOne(current); // copies are removed from the list of selected screenshots about to add
    }                                               // ...non-supported files are also removed

    if ( !screenshotsSelected.isEmpty() ) {

        lastSelectedScreenshotDir = screenshotsSelected.last().section('/', 0, -2);
        populateScreenshotQueue(screenshotsSelected);
        screenshotPathsPool << screenshotsSelected;
        emit sendWidgetsDisabled( QStringList() << "pushButton_clearQueue" << "pushButton_copyScreenshots", false );
    }
}


void Controller::receiveTreeWidgetPointer(QTreeWidgetDragAndDrop *receivedWidget)
{
    treeWidget = receivedWidget;

    QObject::connect(treeWidget,    &QTreeWidgetDragAndDrop::sendDroppedScreenshots,
                     this,          &Controller::addScreenshotsToPool);
}


QStringList Controller::readVDF()   // read text from the VDF and return it in the form of list of strings for easy manipulating
{
    QFile vdf(userDataDir + "/" + selectedUserID + "/" + vdfFilename);
    vdf.open(QIODevice::ReadOnly | QIODevice::Text);
    QTextStream text(&vdf);
    QStringList lines;

    while ( !text.atEnd() ) {
        QString line = text.readLine();
        lines << line;
    }

    vdf.close();
    return lines;
}


void Controller::writeVDF()         // write to VDF from list of strings. previous contents are discarded
{
    QString vdfPath = userDataDir + "/" + selectedUserID + "/" + vdfFilename;
    QFile(vdfPath).copy(vdfPath + ".bak"); // backup VDF just in case

    QFile vdf(vdfPath);
    vdf.open(QIODevice::WriteOnly | QIODevice::Truncate);
    QTextStream text(&vdf);

    QListIterator<QString> i(lines);
    while ( i.hasNext() ) {
        QString current = i.next();
        text << current + "\n";
    }

    vdf.close();
}


void Controller::prepareScreenshots(QString userID, QString gameID, quint32 jpegQuality, MainWindow *mainWindow)   // this routine copies screenshots to the respective folders
{                                                                   // ...and manipulates a string list copy of the VDF (file is not written yet)
    someScreenshotsWereNotPrepared = false;
    QRegularExpression desc(" <.+>$");
    selectedUserID = userID.replace("\\", "/").remove(desc);
    selectedGameID = gameID.remove(desc);   // it's possible to enter game ID by hand or left what was auto-generated (with <...>)
    selectedJpegQuality = jpegQuality;

    if ( lines.isEmpty() )
        lines = readVDF();

    QString path = userDataDir + "/" + selectedUserID + "/remote/" + selectedGameID + "/screenshots/thumbnails";
    if ( !QDir().exists(path) )
        QDir().mkpath(path);

    QRegularExpression re("^\t\"" + selectedGameID + "\"$");        // calculate a location for inserting new screenshot metadata
    qint32 header = lines.indexOf(re, 0);

    opening = 0;

    if ( header == -1 ) {

        QList<qint32> headers;

        qint32 pos = 0;
        re.setPattern("^\t\"[0-9]+\"$");
        while ( lines.indexOf(re, pos) != -1 ) {
            pos = lines.indexOf(re, pos + 1);
            if ( pos == -1 )
                break;
            QString h = lines[pos].section('"', 1, -2);
            headers.append(h.toInt());
        }

        qint32 before = -1;

        if ( !headers.isEmpty() ) {

            bool unorderedHeaders = false;

            for ( qint32 i = 0; i < headers.length() - 1; i++ ) {
                if (headers[i] > headers[i + 1])
                    unorderedHeaders = true;
            }

            if ( !unorderedHeaders ) {              // normally, all headers in the VDF are ordered, e.g. game ID 1000 is situated before 2000 in the file
                QListIterator<qint32> i(headers);   // ...otherwise VDF is considered dirty and will not be manipulated, to prevent accidental messing things up
                while ( i.hasNext() ) {
                    qint32 current = i.next();
                    if ( selectedGameID.toInt() < current) {
                        before = current;
                        break;
                    }
                }
            }
        }

        quint32 insertPos;
        if ( before != -1 ) {
            QRegularExpression re("^\t\"" + QString::number(before) + "\"$");
            insertPos = lines.indexOf(re, 0);
        } else
            insertPos = lines.indexOf("\t\"shortcutnames\"");

        lines.insert(insertPos, "\t}");
        lines.insert(insertPos, "\t{");
        lines.insert(insertPos, "\t\"" + selectedGameID +"\"");
        header = insertPos;
        opening = insertPos + 1;
        closing = insertPos + 2;
    }

    if ( lines[header + 1] == "\t{" ) {

        opening = header + 1;
        closing = lines.indexOf("\t}", opening);

        if ( (header != -1) && (opening != -1) && (closing != -1) ) {

            qint32 lastEntryPos = -1;

            if ( closing - opening != 1 ) {
                QRegularExpression re("^\t\t\"[0-9]+\"$");
                lastEntryPos = lines.lastIndexOf(re, closing);
            } else
                lastEntryValue = -1;

            if ( lastEntryPos == -1 )
                lastEntryValue = -1;

            if ( lastEntryValue != -1 )
                lastEntryValue = lines[lastEntryPos].section('"', 1, -2).toInt();

            // routine to detect timestamp overlaps
            QMap<QString, quint32> repeatingTimestamps;
            QList<QStringList> screenshotPool;
            {
                QListIterator<QString> i(screenshotPathsPool);
                while ( i.hasNext() ) {

                    QString path = i.next();
                    QString timestamp = QFileInfo(QFile(path)).lastModified().toString("yyyyMMddhhmmss");
                    QString filename;
                    quint32 inc = 1;

                    for ( qint32 j = screenshotPathsPool.indexOf(path); j < screenshotPathsPool.length(); ++j ) {

                        QString comparedTimestamp = QFileInfo(QFile(screenshotPathsPool[j])).lastModified().toString("yyyyMMddhhmmss");

                        if ( timestamp == comparedTimestamp ) {

                            if ( !repeatingTimestamps.contains(timestamp) )
                                repeatingTimestamps[timestamp] = 0;
                            else
                                ++repeatingTimestamps[timestamp];   // if timestamp is non-unique for this set, increment the integer in the end of a filename

                            inc = repeatingTimestamps[timestamp] + 1;

                            break;
                        }
                    }

                    filename = timestamp + "_" + QString::number(inc) + ".jpg";
                    screenshotPool << ( QStringList() << path << filename );
                }
            }

            copyDest = userDataDir + "/" + selectedUserID + "/remote/" + selectedGameID + "/screenshots/";
            quint32 id = 0;
            bool thereAreLargeScreenshots = false;

            emit sendProgressBarLength(screenshotPool.length());

            QListIterator<QStringList> i(screenshotPool);
            while ( i.hasNext() ) {

                QStringList current = i.next();
                QImage image(current[0]);

                if (!image.isNull()) {                      // sometimes image files are messed up, e.g. JPG files saved with the PNG extension

                    quint32 width = image.size().width();   // ...still they can be opened by some image viewers, but Qt doesn't tolerate such files and crahes the program
                    quint32 height = image.size().height(); // ...hence such files should be discarded from the queue

                    QList<quint32> geometry = QList<quint32>() << width << height;

                    if ( (width > steamMaxSideSize) || (height > steamMaxSideSize) || ((width * height) > steamMaxResolution) ) {
                        QPixmap thumbnail = QPixmap::fromImage(image).scaled(320, 180, Qt::KeepAspectRatio);
                        preparedScreenshotList << Screenshot({id, current, thumbnail, geometry, true, 0});
                        thereAreLargeScreenshots = true;
                    }
                    else {
                        preparedScreenshotList << Screenshot({id, current, QPixmap(), geometry, false, 0});
                    }
                }
                else {
                    someScreenshotsWereNotPrepared = true;
                    emit deleteCopiedWidgetItem(current[0]);
                }

                emit sendProgressBarValue(id + 1);
                id++;
                QCoreApplication::processEvents();
            }

            if (!preparedScreenshotList.isEmpty()) {

                emit sendLabelsVisible(QStringList() << "label_progress" << "label_status" << "progressBar_status", false);

                if (thereAreLargeScreenshots) {
                    emit sendLabelsVisible(QStringList() << "label_progress" << "label_status", true);
                    emit sendStatusLabelText("waiting for user decision", "");
                    getUserDecisionAboutLargeScreenshots(preparedScreenshotList, mainWindow);
                }
                else
                    pushScreenshots(preparedScreenshotList);                
            }
            else {
                sendLabelsVisible(QStringList() << "label_progress" << "progressBar_status", false);
                sendLabelsVisible(QStringList() << "label_status", true);
                emit sendStatusLabelText("none of screenshots were copied", warningColor);
                screenshotPathsPool.clear();
            }
        }
    }
}


void Controller::getUserDecisionAboutLargeScreenshots(QList<Screenshot> screenshotList, MainWindow *mainWindow)
{
    QList<Screenshot> largeScreenshotList;

    QListIterator<Screenshot> i(screenshotList);
    while ( i.hasNext() ) {

        Screenshot current = i.next();

        if (current.isLarge) {
            largeScreenshotList << current;
        }
    }

    if (largeScreenshotList.length() > 0) {

        largeFileDialog = new LargeFileDialog(mainWindow);

        // set some connections here beforehand, because it will be harder to do in the window's own object
        QObject::connect(this,              &Controller::sendScreenshotList,
                         largeFileDialog,   &LargeFileDialog::getDecisions);

        QObject::connect(largeFileDialog,   &LargeFileDialog::sendButtonList,
                         this,              &Controller::getButtonList);

        QObject::connect(largeFileDialog,   &LargeFileDialog::returnScreenshotListWithDecisions,
                         this,              &Controller::prepareScreenshotListWithDecisions);

        emit sendScreenshotList(largeScreenshotList, mainWindow->frameGeometry().center(),
                                QStringList() << QString::number(steamMaxSideSize) << QString::number(steamMaxResolution));
    }
}


void Controller::prepareScreenshotListWithDecisions(QList<Screenshot> screenshotList)
{
    emit sendLabelsVisible(QStringList() << "label_progress" << "label_status", false);

    QListIterator<Screenshot> i(screenshotList);
    while ( i.hasNext() ) {

        Screenshot current = i.next();

        for (qint32 j=0; j < preparedScreenshotList.length(); j++)
            if (current.id == preparedScreenshotList[j].id)
                preparedScreenshotList[j].decision = current.decision;
    }

    pushScreenshots(preparedScreenshotList);
}


void Controller::resizeAndSaveLargeScreenshot(Screenshot screenshot)
{
    QString filename = screenshot.screenshot[1];
    QImage image(screenshot.screenshot[0]);
    QImage resizedImage;
    quint32 width = screenshot.geometry[0];
    quint32 height = screenshot.geometry[1];

    bool rectangular = true;
    quint32 newWidth = 0;
    quint32 newHeight = 0;

    if (width == height) {                                                      // square, large side

        newWidth = qRound(qSqrt(steamMaxResolution));
        newHeight = newWidth;
        rectangular = false;

    } else if ( (width > steamMaxSideSize) || (height > steamMaxSideSize) ) {   // rectangle, large side(s)

        if (width > height) {   // horizontal
            newWidth = steamMaxSideSize;
            newHeight = (steamMaxSideSize * height) / width;
        } else {                // vertical
            newHeight = steamMaxSideSize;
            newWidth = (steamMaxSideSize * width) / height;
        }

        width = newWidth;
        height = newHeight;

    }

    if (rectangular && (width * height > steamMaxResolution)) {                 // rectangle, large resolution

        qreal ratio = width / qreal(height);
        newHeight = qFloor(qSqrt(steamMaxResolution / ratio));
        newWidth = qFloor(newHeight * ratio);

    }

    saveThumbnail(filename, image, newWidth, newHeight);

    resizedImage = image.scaled(QSize(newWidth, newHeight), Qt::KeepAspectRatio, Qt::SmoothTransformation);
    resizedImage.save(copyDest + filename, "jpg", selectedJpegQuality);
}


void Controller::saveThumbnail(QString filename, QImage image, quint32 width, quint32 height)
{
    // Teilen durch Null verhindern.
    if (width == 0 || height == 0) {
        qWarning() << "saveThumbnail: invalid image size for" << filename;
        return; // Methode wird verlassen. Kein Thumbnail erstellt. Steam muss ein eigenes erzeugen.
    }

    QImage thumb;
    const quint32 maxEdge = 200; // Maximale Kantenlänge 200 Pixel

    if (width >= height) {
        thumb = image.scaledToWidth(maxEdge, Qt::SmoothTransformation);
    } else {
        thumb = image.scaledToHeight(maxEdge, Qt::SmoothTransformation);
    }

    thumb.save(copyDest + "/thumbnails/" + filename, "jpg", 95);
}

// void Controller::saveThumbnail(QString filename, QImage image, quint32 width, quint32 height)
// {
//     quint32 tnWidth = 200;
//     quint32 tnHeight = (tnWidth * height) / width;

//     image.scaled(QSize(tnWidth, tnHeight), Qt::IgnoreAspectRatio, Qt::SmoothTransformation)
//         .save(copyDest + "/thumbnails/" + filename, "jpg", 95);
// }


QString Controller::getEncodingProcessOfJpeg(QFile *file)    // implemented to mitigate the issue #9: https://github.com/Foyl/SteaScree/issues/9
{                                                            // Qt is pretty lame at reading JPEG data, so I ended up reading up raw binary data
    file->open(QIODevice::ReadOnly);
    int bufferLength = 10000;                     // read just first 10 kilobytes from a given file, JPEG markers SOF0 or SOF2 should be there
    QByteArray someBytes = file->read(bufferLength);
    file->close();

    if (someBytes.length() < bufferLength)
        bufferLength = someBytes.length();

    QString encodingProcess = "unidentified";

    if ((someBytes[0] == ((char) 0xFF)) && (someBytes[1] == ((char) 0xD8))) // all proper JPEGs have 0xFF and 0xD8 bytes in the beginning
        for (int i = 1; i < bufferLength - 1; i++)
            if (someBytes[i] == (char) 0xFF) {
                if (someBytes[i + 1] == (char) 0xC0) {
                    encodingProcess = "baseline";
                    break;
                }
                else if (someBytes[i + 1] == (char) 0xC2) {
                    encodingProcess = "progressive";
                    break;
                }
            }

    return encodingProcess;
}


void Controller::pushScreenshots(QList<Screenshot> screenshotList)
{
    emit sendProgressBarLength(screenshotList.length());
    emit sendLabelsVisible(QStringList() << "label_progress" << "label_status" << "progressBar_status", true);
    emit sendStatusLabelText("copying screenshots", "");

    QListIterator<Screenshot> i(screenshotList);
    while ( i.hasNext() ) {

        Screenshot current = i.next();

        QString path = current.screenshot[0];

        if (current.isLarge && current.decision == 2) {
            emit deleteCopiedWidgetItem(path);
            continue;                                               // skip file if it is large and user decided not to upload it
        }

        QString filename = current.screenshot[1];

        QFile file(path);
        QString extension = path.section('.', -1).toLower();

        quint32 width = current.geometry[0];
        quint32 height = current.geometry[1];

        QImage image(path);

        if ( !(QFile(copyDest + filename).exists()) ) {

            if (!current.isLarge || current.decision == 3) {

                if ( ((extension == "jpg") || (extension == "jpeg")) && (getEncodingProcessOfJpeg(&file) == "progressive") )
                    file.copy(copyDest + filename);                 // copy untouched JPEG file if it is really JPEG, is not large (or if user decided to try it upload anyway)
                else                                                // ...only progressive JPEGs are copied as is, baseline or some unidentified jpegs are
                    image.save(copyDest + filename, "jpg", selectedJpegQuality);    // ...getting processed and saved by Qt to prevent Steam Cloud to reject them

                saveThumbnail(filename, image, width, height);      // ...see issue https://github.com/Foyl/SteaScree/issues/9

            } else                                                  // it is large and the user decision is "resize"
                resizeAndSaveLargeScreenshot(current);

            emit sendLabelsText( QStringList() << "label_infoScreenshots", QString::number(++copiedScreenshotsNum) );
        }

        QDateTime lm = QFileInfo(file).lastModified();
        qint64 epoch = lm.toMSecsSinceEpoch();
        QString creation = QString::number(epoch/1000);

        // vdf data preparation
        if ( lines.mid( opening, closing - opening )
             .contains("\t\t\t\"filename\"\t\t\"" + selectedGameID + "/screenshots/" + filename + "\"") ) {
            emit deleteCopiedWidgetItem(path);
            continue;
        }

        lines.insert(closing++, "\t\t\"" + QString::number(++lastEntryValue) + "\"");
        lines.insert(closing++, "\t\t{");
        lines.insert(closing++, "\t\t\t\"type\"\t\t\"1\"");
        lines.insert(closing++, "\t\t\t\"filename\"\t\t\"" + selectedGameID + "/screenshots/" + filename + "\"");
        lines.insert(closing++, "\t\t\t\"thumbnail\"\t\t\"" + selectedGameID + "/screenshots/thumbnails/" + filename + "\"");
        lines.insert(closing++, "\t\t\t\"vrfilename\"\t\t\"\"");
        lines.insert(closing++, "\t\t\t\"imported\"\t\t\"0\"");
        lines.insert(closing++, "\t\t\t\"width\"\t\t\"" + QString::number(width) + "\"");
        lines.insert(closing++, "\t\t\t\"height\"\t\t\"" + QString::number(height) + "\"");
        lines.insert(closing++, "\t\t\t\"gameid\"\t\t\"" + selectedGameID + "\"");
        lines.insert(closing++, "\t\t\t\"creation\"\t\t\"" + creation + "\"");
        lines.insert(closing++, "\t\t\t\"caption\"\t\t\"\"");
        lines.insert(closing++, "\t\t\t\"Permissions\"\t\t\"\"");
        lines.insert(closing++, "\t\t\t\"hscreenshot\"\t\t\"\"");
        lines.insert(closing++, "\t\t}");

        addedLines++;

        emit sendProgressBarValue(screenshotPathsPool.indexOf(path) + 1);
        emit deleteCopiedWidgetItem(path);

        if ( !copiedGames.contains(selectedGameID) ) {
            copiedGames << selectedGameID;
            copiedDirsToNum++;
        }

        QCoreApplication::processEvents();
    }

    emit sendLabelsVisible(QStringList() << "label_progress" << "progressBar_status", false);
    emit sendWidgetsDisabled(QStringList() << "pushButton_addScreenshots" << "comboBox_gameID", false);
    emit sendLabelsCleared(QStringList() << "label_status");

    if (addedLines > 0) {
        emit sendLabelsText(QStringList() << "label_infoDirectories", QString::number(copiedDirsToNum));
        emit sendDirStatusLabelsVisible(true);

        if (someScreenshotsWereNotPrepared)
            emit sendStatusLabelText("some screenshots were not copied", warningColor);
        else
            emit sendStatusLabelText("screenshots are ready for preparation", "");

        emit sendWidgetsDisabled(QStringList() << "pushButton_prepare", false);
    }

    screenshotPathsPool.clear();
    preparedScreenshotList.clear();
}


void Controller::getButtonList(QList<QPushButton*> buttonList)
{
    emit adjustButtons(buttonList, os);
}


void Controller::removeEntryFromScreenshotPathsPool(QString entry)
{
    screenshotPathsPool.removeOne(entry);
}


QString Controller::convertSlashes(QString str)
{
    QString converted;

    if ( isUnixLikeOS )
        converted = str;
    else
        converted = str.replace("/", "\\");

    return converted;
}


void Controller::returnLinesState()
{
    emit sendLinesState(addedLines);
}


void Controller::clearScreenshotPathsPool()
{
    screenshotPathsPool.clear();
}


void Controller::clearState()
{
    addedLines = 0;
    lines.clear();
    copiedGames.clear();
}


void Controller::clearCopyingStatusLabels()
{
    copiedScreenshotsNum = 0;
    copiedDirsToNum = 0;
}


void Controller::returnLastSelectedScreenshotDir()
{
    emit sendLastSelectedScreenshotDir(lastSelectedScreenshotDir);
}


void Controller::returnSteamDir()
{
    emit sendSteamDir(steamDir);
}


void Controller::loadFirstScreenshotForGame(QString gameID)
{
    //qDebug() << "loadFirstScreenshotForGame aufgerufen: " << gameID;

    if (currentUserID.isEmpty() || steamDir.isEmpty()){
        // qDebug() << "currentUserID oder steamDir ist leer!";
        // qDebug() << "currentUserID:" << currentUserID;
        // qDebug() << "steamDir:" << steamDir;
        return;
    }

    // Nur die führende Zahl extrahieren
    QRegularExpression re("^(\\d+)");
    QRegularExpressionMatch match = re.match(gameID);

   // qDebug() << "loadFirstScreenshotForGame match: " << match;
    if (!match.hasMatch()) {
        emit sendPreviewImage(QPixmap());
        return;
    }

    QString numericGameID = match.captured(1);

    QString path = QString("%1/userdata/%2/760/remote/%3/screenshots")
                       .arg(steamDir, currentUserID, numericGameID);

    //Pfad merken für pushButtonPreview
    lastSelectedScreenshotPath = path;

    //qDebug() << "loadFirstScreenshotForGame QString path: " << path;
    // qDebug() << "Überprüfe Screenshot-Pfad:" << path;
    // qDebug() << "SteamDir:" << steamDir;
    // qDebug() << "currentUserID:" << currentUserID;
    QDir userdataDir(QString("%1/userdata").arg(steamDir));
    // qDebug() << "Gefundene UserIDs:" << userdataDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);

    QDir dir(path);
    if (!dir.exists()) {
        // qDebug() << "Screenshot-Ordner existiert nicht:" << path;
        emit sendPreviewImage(QPixmap());
        return;
    }

    QStringList filters = {"*.jpg", "*.jpeg", "*.png", "*.bmp", "*.tif", "*.tiff"};
    // QStringList files = dir.entryList(filters, QDir::Files, QDir::Name | QDir::Reversed); // Reihenfolge umgekehrt, von neu nach alt sortiert
    QStringList files = dir.entryList(filters, QDir::Files, QDir::Name);


    // qDebug() << "Gefundene Dateien:" << files;

    if (files.isEmpty()) {
        emit sendPreviewImage(QPixmap());
        return;
    }

    // Bilderliste speichern
    m_screenshotFiles = files;
    m_currentScreenshotIndex = files.size() - 1;

    // m_currentScreenshotIndex = 0;

    // QString firstImagePath = dir.absoluteFilePath(files.first());
    QString firstImagePath = dir.absoluteFilePath(files[m_currentScreenshotIndex]);

    QPixmap pix(firstImagePath);
    // qDebug() << "loadFirstScreenshotForGame firstImagePath: " << firstImagePath;

    emit sendPreviewImage(pix);
    // emit sendPreviewCount(m_currentScreenshotIndex + 1, m_screenshotFiles.size());

    //Reihenfolge umdrehen für label_previewCount, neuestes Bild ist höchste Zahl
    // int total = m_screenshotFiles.size();
    // int displayIndex = total - m_currentScreenshotIndex;
    // emit sendPreviewCount(displayIndex, total);
  //  int total = m_screenshotFiles.size();
    emit sendPreviewCount(m_currentScreenshotIndex + 1, files.size());

    // emit sendPreviewCount(m_currentScreenshotIndex +1, total);
}


void Controller::onUserIDSelected(const QString &userID)
{
    // userID aus ComboBox kann "12345678" oder "12345678 <Name>" sein
    QRegularExpression re("^(\\d+)");
    QRegularExpressionMatch match = re.match(userID);
    if (match.hasMatch()) {
        currentUserID = match.captured(1);
        // qDebug() << "currentUserID gesetzt auf:" << currentUserID;
    } else {
        currentUserID.clear();
        // qDebug() << "Ungültige UserID aus ComboBox:" << userID;
    }
}


QString Controller::getLastSelectedScreenshotPath() const
{
    return lastSelectedScreenshotPath;
}


// void Controller::showNextScreenshot()
// {
//     if (lastSelectedScreenshotPath.isEmpty() || m_screenshotFiles.isEmpty())
//         return;

//     if (m_currentScreenshotIndex + 1 < m_screenshotFiles.size())
//         m_currentScreenshotIndex++;
//     else
//         m_currentScreenshotIndex = 0; // wieder von vorn beginnen

//     QString nextImagePath = QDir(lastSelectedScreenshotPath).absoluteFilePath(m_screenshotFiles[m_currentScreenshotIndex]);
//     emit sendPreviewImage(QPixmap(nextImagePath));
//     emit sendPreviewCount(m_currentScreenshotIndex + 1, m_screenshotFiles.size());
// }

// void Controller::showPreviousScreenshot()
// {
//     if (lastSelectedScreenshotPath.isEmpty() || m_screenshotFiles.isEmpty())
//         return;

//     if (m_currentScreenshotIndex - 1 >= 0)
//         m_currentScreenshotIndex--;
//     else
//         m_currentScreenshotIndex = m_screenshotFiles.size() - 1; // zum letzten Bild springen

//     QString prevImagePath = QDir(lastSelectedScreenshotPath).absoluteFilePath(m_screenshotFiles[m_currentScreenshotIndex]);
//     emit sendPreviewImage(QPixmap(prevImagePath));
//     emit sendPreviewCount(m_currentScreenshotIndex + 1, m_screenshotFiles.size());
// }

void Controller::setApiKey(QString key){
    apiKey = key;

    if (settings) {
        settings->beginGroup("LastSelection");
        settings->setValue("ApiKey", encryptAPIKey(apiKey));
        //settings->setValue("ApiKey", apiKey);
        settings->endGroup();
    }
}


void Controller::setApiIndex(int index)
{
    apiIndex = index;
}


void Controller::clearApiKey()
{
    apiKey.clear();
    settings->beginGroup("LastSelection");
    settings->remove("ApiKey");
    settings->endGroup();

    emit sendApiKeyState(false); // Benachrichtigt das UI, dass kein Key mehr vorhanden ist
    emit sendStatusLabelText("API Key deleted", "green");
}


void Controller::setScreenshotIndex(int index)
{
    if (lastSelectedScreenshotPath.isEmpty() || m_screenshotFiles.isEmpty())
        return;

    if (index < 0 || index >= m_screenshotFiles.size())
        return;

    m_currentScreenshotIndex = index;

    QString imgPath = QDir(lastSelectedScreenshotPath)
                          .absoluteFilePath(m_screenshotFiles[index]);

    emit sendPreviewImage(QPixmap(imgPath));
    emit sendPreviewCount(index + 1, m_screenshotFiles.size());


}


// HEAD-Abfrage, prüft schnell und sparsam die Verfügbarkeit der API-Server, aber keine Aussage über gelieferte Daten
void Controller::checkApiReachability(const QUrl &url)
{
    auto *manager = new QNetworkAccessManager(this);

    QNetworkRequest request(url);
    //request.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true); //No Member FollowRedirectsAttribute in QNetworkRequest / QtVersion

    QNetworkReply *reply = manager->head(request);

    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        bool erreichbar = false;

        if (reply->error() == QNetworkReply::NoError) {
            // Antwort erhalten, API lebt
            erreichbar = true;
        }

        // Statusanzeige auf Benutzeroberfläche aktualisieren
        emit apiReachabilityChanged(erreichbar);

        reply->deleteLater();
    });
}

// GET-Abfrage für Statusprüfung (Verursacht mehr Datenverkehr, ist langsam, aber würde aussagen, dass Daten geliefert werden)
// void Controller::checkApiReachability(const QUrl &url)
// {
//     QNetworkRequest req(url);
//     req.setRawHeader("Accept", "application/json");

//     auto *mgr = new QNetworkAccessManager(this);
//     QNetworkReply *reply = mgr->get(req);

//     connect(reply, &QNetworkReply::finished, this, [=]() {

//         bool erreichbar = (reply->error() == QNetworkReply::NoError);

//         emit apiReachabilityChanged(erreichbar);

//         reply->deleteLater();
//         mgr->deleteLater();
//     });
// }


void Controller::resetSettings()
{
    if(!settings) return;

    settings->clear();
    settings->sync();

    bootStrap();
    //emit settingsReset();
}



QString Controller::loadJsonLocal()
{
    QString path = QCoreApplication::applicationDirPath() + "/games.json";
    QFile file(path);

    emit updateStatusMessage("Loading games.json from local folder: " + path);

    if (!file.exists())
        return ""; // nicht vorhanden

    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
        return "";

    qDebug() << "loadJsonLocal(): JSON found!";

    return file.readAll();
}


void Controller::loadJsonFromGithub()
{
    QString url = "https://raw.githubusercontent.com/Alsweider/SteaScreeLoaded/refs/heads/master/games.json";

    QNetworkAccessManager *nam = new QNetworkAccessManager(this);
    QNetworkReply *reply = nam->get(QNetworkRequest(QUrl(url)));

    QObject::connect(reply, &QNetworkReply::finished, this, [=]() {
        if (reply->error() != QNetworkReply::NoError) {
            qDebug() << "Mirror download failed:" << reply->errorString();
            emit sendToComboBox("comboBox_gameID", QStringList() << "JSON download failed");
            emit updateStatusMessage("JSON download from online source failed.");
            return;
        }
        qDebug() << "loadJsonFromGithub(): JSON found!";
        emit updateStatusMessage("Loading games.json from online source.");

        QByteArray raw = reply->readAll();

        // lokal speichern
        QString path = QCoreApplication::applicationDirPath() + "/games.json";
        QFile file(path);
        if (file.open(QIODevice::WriteOnly | QIODevice::Text))
            file.write(raw);

        parseJson(raw);
    });
}


void Controller::parseJson(const QByteArray &raw)
{
    QJsonDocument doc = QJsonDocument::fromJson(raw);
    if (!doc.isObject())
        return;

    QJsonObject obj = doc.object();
    games.clear();

    for (auto it = obj.begin(); it != obj.end(); ++it) {
        QString appID = it.key();
        QString name  = it.value().toString();
        games[appID] = name;
    }

    fillGameIDs(userID);
}


QString Controller::encryptAPIKey(const QString &plain)
{
    QByteArray data = plain.toUtf8();

    // PKCS7 Padding auf 16-Byte-Blöcke
    int pad = 16 - (data.size() % 16);
    data.append(pad, char(pad));

    QByteArray buffer = data;

    struct AES_ctx ctx;
    AES_init_ctx_iv(&ctx, AES_KEY, AES_IV);

    AES_CBC_encrypt_buffer(&ctx,
                           reinterpret_cast<uint8_t*>(buffer.data()),
                           buffer.size());

    return buffer.toBase64();
}

QString Controller::decryptAPIKey(const QString &enc)
{
    QByteArray buffer = QByteArray::fromBase64(enc.toUtf8());

    struct AES_ctx ctx;
    AES_init_ctx_iv(&ctx, AES_KEY, AES_IV);

    AES_CBC_decrypt_buffer(&ctx,
                           reinterpret_cast<uint8_t*>(buffer.data()),
                           buffer.size());

    // Padding entfernen
    if (!buffer.isEmpty()) {
        int pad = buffer.at(buffer.size() - 1);
        if (pad > 0 && pad <= 16) {
            buffer.chop(pad);
        }
    }

    return QString::fromUtf8(buffer);
}


QString Controller::getCurrentScreenshotPath() const
{
    if (lastSelectedScreenshotPath.isEmpty() || m_screenshotFiles.isEmpty())
        return QString();

    return QDir(lastSelectedScreenshotPath)
        .absoluteFilePath(m_screenshotFiles[m_currentScreenshotIndex]);
}