temp_mainwindow.cpp

#include "mainwindow.h"
#include "glassbutton.h"
#include "gamecard.h"
#include "loadingspinner.h"
#include "gamedetailspage.h"
#include "socialpage.h"
#include "profilecard.h"
#include "customtitlebar.h"
#include "materialicons.h"
#include "notificationdialog.h"
#include "chatpage.h"
#include "friendpopover.h"
#include "userprofiledialog.h"
#include "workers/indexdownloadworker.h"
#include "workers/luadownloadworker.h"
#include "workers/generatorworker.h"
#include "workers/restartworker.h"
#include "workers/steampatchworker.h"
#include "utils/colors.h"
#include "utils/gameinfo.h"
#include "terminaldialog.h"
#include "addfrienddialog.h"
#include "utils/paths.h"
#include "config.h"
#include <QBuffer>
#include <QProcess>
#include <QApplication>
#include <QImageWriter>

#ifdef Q_OS_WIN
#include <windows.h>
#include <dwmapi.h>
#include <windowsx.h>
// windows.h defines ERROR as a macro which conflicts with Colors::ERROR
#undef ERROR
#endif

#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QPointer>
#include <QFileDialog>
#include <QStackedLayout>
#include <QPropertyAnimation>
#include <QPainter>
#include <QLinearGradient>
#include <QGraphicsDropShadowEffect>
#include <QMessageBox>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QUrlQuery>
#include <QFile>
#include <QDir>
#include <QPixmap>
#include <QPainterPath>
#include <QFileDialog>
#include <QScrollBar>
#include <QRandomGenerator>
#include <algorithm>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QMimeData>
#include <QSettings>
#include <QStandardPaths>
#include <QMouseEvent>
#include <QScreen>
#include <QGuiApplication>
#include <QNetworkDiskCache>

// ==========================================
// HeroBannerWidget Implementation
// ==========================================

HeroBannerWidget::HeroBannerWidget(QWidget* parent) : QWidget(parent), m_imageScale(1.05) {
    m_scaleAnim = new QPropertyAnimation(this, "imageScale", this);
    m_scaleAnim->setDuration(1000);
    m_scaleAnim->setEasingCurve(QEasingCurve::OutSine);
    setStyleSheet("border-radius: 12px; border: none; background: transparent;");
}

void HeroBannerWidget::setPixmap(const QPixmap& p) {
    m_pixmap = p;
    update();
}

void HeroBannerWidget::paintEvent(QPaintEvent* event) {
    Q_UNUSED(event);
    if (m_pixmap.isNull()) return;
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing);
    p.setRenderHint(QPainter::SmoothPixmapTransform);
    QPainterPath path;
    path.addRoundedRect(rect(), 12, 12);
    p.setClipPath(path);
    p.translate(rect().center());
    p.scale(m_imageScale, m_imageScale);
    p.translate(-rect().center());
    QSize targetSize = rect().size();
    QPixmap scaled = m_pixmap.scaled(targetSize, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation);
    int sx = qMax(0, (scaled.width() - targetSize.width()) / 2);
    int sy = qMax(0, (scaled.height() - targetSize.height()) / 2);
    int sw = qMin(targetSize.width(), scaled.width() - sx);
    int sh = qMin(targetSize.height(), scaled.height() - sy);
    p.drawPixmap(rect(), scaled, QRect(sx, sy, sw, sh));
}

void HeroBannerWidget::enterEvent(QEnterEvent* event) {
    m_scaleAnim->stop();
    m_scaleAnim->setStartValue(m_imageScale);
    m_scaleAnim->setEndValue(1.0);
    m_scaleAnim->start();
    QWidget::enterEvent(event);
}

void HeroBannerWidget::leaveEvent(QEvent* event) {
    m_scaleAnim->stop();
    m_scaleAnim->setStartValue(m_imageScale);
    m_scaleAnim->setEndValue(1.05);
    m_scaleAnim->start();
    QWidget::leaveEvent(event);
}

// ==========================================
// MainWindow Implementation
// ==========================================

// ΓöÇΓöÇ Inline helper: a QWidget that paints a single Material icon ΓöÇΓöÇ
class MaterialIconWidget : public QWidget {
public:
    MaterialIconWidget(MaterialIcons::Icon icon, const QColor& color, int size = 24, QWidget* parent = nullptr)
        : QWidget(parent), m_icon(icon), m_color(color) {
        setFixedSize(size, size);
        setAttribute(Qt::WA_TranslucentBackground);
    }
protected:
    void paintEvent(QPaintEvent*) override {
        QPainter p(this);
        p.setRenderHint(QPainter::Antialiasing);
        QRectF r(4, 4, width() - 8, height() - 8);
        MaterialIcons::draw(p, r, m_color, m_icon);
    }
private:
    MaterialIcons::Icon m_icon;
    QColor m_color;
};

// ΓöÇΓöÇ Inline helper: a QPushButton that paints a Material icon ΓöÇΓöÇ
class MaterialIconButton : public QPushButton {
public:
    MaterialIconButton(MaterialIcons::Icon icon, const QColor& color, int size = 40, QWidget* parent = nullptr)
        : QPushButton(parent), m_icon(icon), m_color(color) {
        setFixedSize(size, size);
        setCursor(Qt::PointingHandCursor);
    }
protected:
    void paintEvent(QPaintEvent*) override {
        QPainter p(this);
        p.setRenderHint(QPainter::Antialiasing);
        // Background
        QColor bg = Colors::toQColor(Colors::SURFACE_CONTAINER_HIGH);
        if (underMouse()) bg = Colors::toQColor(Colors::SURFACE_CONTAINER_HIGHEST);
        QPainterPath path;
        path.addRoundedRect(QRectF(rect()), width() / 2.0, height() / 2.0);
        p.fillPath(path, bg);
        // Icon
        int pad = 10;
        QRectF iconRect(pad, pad, width() - 2 * pad, height() - 2 * pad);
        MaterialIcons::draw(p, iconRect, m_color, m_icon);
    }
private:
    MaterialIcons::Icon m_icon;
    QColor m_color;
};

MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)
    , m_currentMode(AppMode::LuaPatcher)
    , m_networkManager(nullptr)
    , m_activeReply(nullptr)
    , m_currentSearchId(0)
    , m_syncWorker(nullptr)
    , m_dlWorker(nullptr)
    , m_genWorker(nullptr)
    , m_restartWorker(nullptr)
    , m_fetchingNames(false)
    , m_nameFetchSearchId(0)
    , m_hasCachedData(false)
    , m_sidebarAvatarLabel(nullptr)
    , m_sidebarUsernameLabel(nullptr)
    , m_sidebarProfileWidget(nullptr)
{
    // Retrieve username first so UI reflects it correctly (Avatar initial)
    // Use AppData folder for settings
    QString appDataPath = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);
    QDir().mkpath(appDataPath);
    QString settingsPath = appDataPath + "/settings.ini";
    QSettings settings(settingsPath, QSettings::IniFormat);
    m_username = settings.value("username", "").toString();
    m_isGuest = settings.value("isGuest", true).toBool();
    QString dataStr = settings.value("userData", "").toString();
    if (!dataStr.isEmpty()) {
        m_userData = QJsonDocument::fromJson(dataStr.toUtf8()).object();
    }

    setWindowTitle("Lua Patcher");
    setMinimumSize(900, 600);
    resize(1280, 820);
    
    // Center window on primary screen
    if (auto screen = QGuiApplication::primaryScreen()) {
        QRect screenGeometry = screen->availableGeometry();
        move(screenGeometry.center() - rect().center());
    }
    
    setAcceptDrops(true);
    
    // ΓöÇΓöÇ Native Frameless Window Approach ΓöÇΓöÇ
    // We do NOT use Qt::FramelessWindowHint here. 
    // Instead, we let the window have its native frame but hide it using WM_NCCALCSIZE.
    // This preserves native window behaviors like taskbar animations, snapping, and system menus.
    
    // ΓöÇΓöÇ Enable Transparency for Desktop Blur ΓöÇΓöÇ
    setAttribute(Qt::WA_TranslucentBackground);
    
    QString iconPath = Paths::getResourcePath("icon.png");
    if (QFile::exists(iconPath)) {
        setWindowIcon(QIcon(iconPath));
    }
    
    // Initialize network manager BEFORE UI is built
    m_networkManager = new QNetworkAccessManager(this);
    
    // Enable persistent disk cache for images (50 MB)
    QNetworkDiskCache* diskCache = new QNetworkDiskCache(this);
    QString cachePath = QDir(Paths::getLocalCacheDir()).filePath("image_cache");
    QDir().mkpath(cachePath);
    diskCache->setCacheDirectory(cachePath);
    diskCache->setMaximumCacheSize(50 * 1024 * 1024); // 50 MB
    m_networkManager->setCache(diskCache);
    
    connect(m_networkManager, &QNetworkAccessManager::finished,
            this, &MainWindow::onSearchFinished);
            
    initUI();
    
    // Apply Desktop Acrylic/Mica Blur
    enableAcrylicBlur();
    
    m_debounceTimer = new QTimer(this);
    m_debounceTimer->setSingleShot(true);
    connect(m_debounceTimer, &QTimer::timeout, this, &MainWindow::doSearch);
    
    m_currentGlowColor = Colors::toQColor(Colors::PRIMARY);
    m_targetGlowColor = m_currentGlowColor;
    m_glowTimer = new QTimer(this);
    connect(m_glowTimer, &QTimer::timeout, this, &MainWindow::updateAmbientGlow);
    
    QTimer::singleShot(10, this, [this]() {
        startSync();
        fetchTrendingGames();
        checkAppUpdate();
    });
}

MainWindow::~MainWindow() {
    if (m_activeReply) {
        m_activeReply->abort();
        m_activeReply->deleteLater();
    }
    
    // Terminate any running network downloader threads cleanly before destruction
    if (m_syncWorker && m_syncWorker->isRunning()) {
        m_syncWorker->requestInterruption();
        m_syncWorker->quit();
        m_syncWorker->wait(100);
    }
}

// ΓöÇΓöÇ Win32 Acrylic/Mica Blur ΓöÇΓöÇ
void MainWindow::enableAcrylicBlur() {
#ifdef Q_OS_WIN
    HWND hwnd = reinterpret_cast<HWND>(winId());
    
    // Step 1: Extend DWM frame into entire client area (required for blur visibility)
    MARGINS margins = {-1, -1, -1, -1};
    DwmExtendFrameIntoClientArea(hwnd, &margins);
    
    // Step 2: Try Windows 11 system backdrop (DWMWA_SYSTEMBACKDROP_TYPE = 38)
    // Value 3 = DWMSBT_TRANSIENTWINDOW (Acrylic ΓÇö see-through blur)
    int backdropType = 3;
    HRESULT hr = DwmSetWindowAttribute(hwnd, 38, &backdropType, sizeof(backdropType));
    
    // Step 3: If Win11 backdrop failed, use SetWindowCompositionAttribute (Win10 1803+)
    if (FAILED(hr)) {
        struct ACCENT_POLICY {
            int AccentState;
            int AccentFlags;
            int GradientColor;
            int AnimationId;
        };
        struct WINDOWCOMPOSITIONATTRIBDATA {
            int Attrib;
            PVOID pvData;
            SIZE_T cbData;
        };
        typedef BOOL(WINAPI* pSetWindowCompositionAttribute)(HWND, WINDOWCOMPOSITIONATTRIBDATA*);
        
        HMODULE hUser = GetModuleHandleA("user32.dll");
        if (hUser) {
            auto SetWCA = (pSetWindowCompositionAttribute)GetProcAddress(hUser, "SetWindowCompositionAttribute");
            if (SetWCA) {
                ACCENT_POLICY policy = {};
                policy.AccentState = 4; // ACCENT_ENABLE_ACRYLICBLURBEHIND
                policy.AccentFlags = 2; // ACCENT_FLAG_DRAW_ALL
                policy.GradientColor = 0x33191B21; // AABBGGRR ΓÇö very light tint, mostly see-through
                
                WINDOWCOMPOSITIONATTRIBDATA data = {};
                data.Attrib = 19; // WCA_ACCENT_POLICY
                data.pvData = &policy;
                data.cbData = sizeof(policy);
                
                SetWCA(hwnd, &data);
            }
        }
    }
#endif
}

// ΓöÇΓöÇ Native event passthrough & Frameless Window Logic ΓöÇΓöÇ
bool MainWindow::nativeEvent(const QByteArray &eventType, void *message, qintptr *result) {
#ifdef Q_OS_WIN
    MSG* msg = static_cast<MSG*>(message);
    switch (msg->message) {
        case WM_NCCALCSIZE: {
            if (msg->wParam) {
                // By returning 0 here, we tell Windows that the client area is the entire window,
                // effectively removing the standard title bar while keeping the window "native".
                *result = 0;
                return true;
            }
            break;
        }
        case WM_NCHITTEST: {
            const long border_width = 8;
            RECT winrect;
            GetWindowRect(msg->hwnd, &winrect);
            long x = GET_X_LPARAM(msg->lParam);
            long y = GET_Y_LPARAM(msg->lParam);

            // 1. Resizing zones (highest priority)
            bool left = x >= winrect.left && x < winrect.left + border_width;
            bool right = x < winrect.right && x >= winrect.right - border_width;
            bool top = y >= winrect.top && y < winrect.top + border_width;
            bool bottom = y < winrect.bottom && y >= winrect.bottom - border_width;

            if (left && top) { *result = HTTOPLEFT; return true; }
            if (left && bottom) { *result = HTBOTTOMLEFT; return true; }
            if (right && top) { *result = HTTOPRIGHT; return true; }
            if (right && bottom) { *result = HTBOTTOMRIGHT; return true; }
            if (left) { *result = HTLEFT; return true; }
            if (right) { *result = HTRIGHT; return true; }
            if (top) { *result = HTTOP; return true; }
            if (bottom) { *result = HTBOTTOM; return true; }

            // 2. Title Bar / Dragging zone
            if (m_titleBar) {
                // Use Qt's DPI-aware coordinate mapping instead of manual ScreenToClient. 
                // This correctly converts physical screen pixels (x, y) to logical widget pixels.
                QPoint localPos = m_titleBar->mapFromGlobal(QPoint(x, y));
                
                if (m_titleBar->rect().contains(localPos)) {
                    // Check if it's over a button inside the title bar
                    QWidget* w = m_titleBar->childAt(localPos);
                    if (w) {
                        // If it's a known system button, return the appropriate hit-test result
                        // to support native hover effects and menus (like Windows 11 Snap Layouts).
                        if (w->objectName() == "minBtn") { *result = HTMINBUTTON; return true; }
                        if (w->objectName() == "maxBtn") { *result = HTMAXBUTTON; return true; }
                        if (w->objectName() == "closeBtn") { *result = HTCLOSE; return true; }
                        
                        // If it's another interactive widget (like a search input), let Qt handle it
                        if (qobject_cast<QPushButton*>(w) || qobject_cast<QLineEdit*>(w)) {
                            return false; 
                        }
                    }
                    *result = HTCAPTION;
                    return true;
                }
            }
            break;
        }
    }
#endif
    return QMainWindow::nativeEvent(eventType, message, result);
}

void MainWindow::onTitleBarMinimize() {
    showMinimized();
}

void MainWindow::onTitleBarMaximize() {
    if (isMaximized()) {
        showNormal();
    } else {
        showMaximized();
    }
}

void MainWindow::onTitleBarClose() {
    close();
}

bool MainWindow::eventFilter(QObject *obj, QEvent *event) {
    if (event->type() == QEvent::MouseButtonPress) {
        if (obj->property("isHeroSlide").toBool()) {
            QString appId = obj->property("gameAppId").toString();
            for (const auto& g : m_supportedGames) {
                if (g.id == appId) {
                    // Build game data without creating a temporary GameCard
                    // (a stack-allocated card would be destroyed when this scope exits,
                    //  leaving m_selectedCard as a dangling pointer → crash on Back)
                    QMap<QString, QString> cd;
                    cd["name"] = m_nameCache.value(g.id, g.id);
                    cd["appid"] = g.id;
                    cd["supported"] = "true";
                    cd["hasFix"] = g.hasFix ? "true" : "false";
                    
                    // Deselect any previously selected card safely
                    if (m_selectedCard) m_selectedCard->setSelected(false);
                    m_selectedCard = nullptr; // No real card for hero slides
                    m_selectedGame = cd;
                    
                    bool isSupported = true;
                    bool hasFix = g.hasFix;
                    m_gameDetailsPage->loadGame(cd["appid"], cd["name"], isSupported, hasFix);
                    m_stack->setCurrentIndex(3);
                    
                    m_targetGlowColor = Colors::toQColor(Colors::PRIMARY);
                    m_glowTimer->start(16);
                    return true;
                }
            }
        } else if (obj == m_topProfileWidget) {
            // Open user profile dialog
            QTimer::singleShot(50, this, [this]() {
                showBlurOverlay();
                UserProfileDialog* dlg = new UserProfileDialog(m_username, m_username, m_networkManager, this);
                dlg->move(geometry().center() - dlg->rect().center());
                
                connect(dlg, &UserProfileDialog::avatarUpdated, this, [this](const QString& b64) {
                    m_userData["avatar_url"] = b64;
                    QString appDataPath = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);
                    QString settingsPath = appDataPath + "/settings.ini";
                    QSettings settings(settingsPath, QSettings::IniFormat);
                    settings.setValue("userData", QJsonDocument(m_userData).toJson());
                    updateSidebarAvatar();
                });
                
                QPointer<MainWindow> guard(this);
                dlg->exec();
                if (guard) guard->hideBlurOverlay();
                dlg->deleteLater();
            });
            return true;
        }
    } else if (obj == m_sidebarWidget) {
        // Sidebar is always expanded ΓÇö no animation
    }
    return QMainWindow::eventFilter(obj, event);
}

void MainWindow::expandSidebar() {
    // Sidebar always expanded ΓÇö no-op
}

void MainWindow::collapseSidebarDelayed() {
    // Sidebar always expanded ΓÇö no-op
}

void MainWindow::scrollCarousel() {
    if (m_heroStack->count() <= 1 || !m_heroStack->isVisible()) return;
    
    int oldIndex = m_currentHeroIndex;
    if (oldIndex >= m_heroStack->count() || oldIndex < 0) {
        oldIndex = 0;
    }
    
    m_currentHeroIndex = oldIndex + 1;
    if (m_currentHeroIndex >= m_heroStack->count()) {
        m_currentHeroIndex = 0;
    }
    
    QWidget* oldSlide = m_heroStack->widget(oldIndex);
    QWidget* newSlide = m_heroStack->widget(m_currentHeroIndex);
    
    if (!oldSlide || !newSlide || oldSlide == newSlide) return;
    
    // Set up opacity effects for crossfade reusing existing if present to avoid animation conflict races
    auto* fadeOutEffect = qobject_cast<QGraphicsOpacityEffect*>(oldSlide->graphicsEffect());
    if (!fadeOutEffect) {
        fadeOutEffect = new QGraphicsOpacityEffect(oldSlide);
        oldSlide->setGraphicsEffect(fadeOutEffect);
    }
    fadeOutEffect->setOpacity(1.0);
    
    auto* fadeInEffect = qobject_cast<QGraphicsOpacityEffect*>(newSlide->graphicsEffect());
    if (!fadeInEffect) {
        fadeInEffect = new QGraphicsOpacityEffect(newSlide);
        newSlide->setGraphicsEffect(fadeInEffect);
    }
    fadeInEffect->setOpacity(0.0);
    
    // Switch to new slide (it's invisible at opacity 0)
    m_heroStack->setCurrentIndex(m_currentHeroIndex);
    
    // Animate fade-out of old slide
    auto* fadeOut = new QPropertyAnimation(fadeOutEffect, "opacity", this);
    fadeOut->setDuration(400);
    fadeOut->setStartValue(1.0);
    fadeOut->setEndValue(0.0);
    fadeOut->setEasingCurve(QEasingCurve::InOutQuad);
    
    // Animate fade-in of new slide
    auto* fadeIn = new QPropertyAnimation(fadeInEffect, "opacity", this);
    fadeIn->setDuration(400);
    fadeIn->setStartValue(0.0);
    fadeIn->setEndValue(1.0);
    fadeIn->setEasingCurve(QEasingCurve::InOutQuad);
    
    fadeOut->start(QAbstractAnimation::DeleteWhenStopped);
    fadeIn->start(QAbstractAnimation::DeleteWhenStopped);
    
    updateHeroIndicators();
}

void MainWindow::jumpToHeroSlide(int index) {
    if (!m_heroStack || index < 0 || index >= m_heroStack->count() || index == m_currentHeroIndex) return;
    
    int oldIndex = m_currentHeroIndex;
    if (oldIndex >= m_heroStack->count() || oldIndex < 0) {
        oldIndex = 0;
    }
    m_currentHeroIndex = index;
    
    QWidget* oldSlide = m_heroStack->widget(oldIndex);
    QWidget* newSlide = m_heroStack->widget(m_currentHeroIndex);
    
    if (!oldSlide || !newSlide || oldSlide == newSlide) return;
    
    auto* fadeOutEffect = qobject_cast<QGraphicsOpacityEffect*>(oldSlide->graphicsEffect());
    if (!fadeOutEffect) {
        fadeOutEffect = new QGraphicsOpacityEffect(oldSlide);
        oldSlide->setGraphicsEffect(fadeOutEffect);
    }
    fadeOutEffect->setOpacity(1.0);
    
    auto* fadeInEffect = qobject_cast<QGraphicsOpacityEffect*>(newSlide->graphicsEffect());
    if (!fadeInEffect) {
        fadeInEffect = new QGraphicsOpacityEffect(newSlide);
        newSlide->setGraphicsEffect(fadeInEffect);
    }
    fadeInEffect->setOpacity(0.0);
    
    m_heroStack->setCurrentIndex(m_currentHeroIndex);
    
    auto* fadeOut = new QPropertyAnimation(fadeOutEffect, "opacity", this);
    fadeOut->setDuration(300);
    fadeOut->setStartValue(1.0);
    fadeOut->setEndValue(0.0);
    fadeOut->setEasingCurve(QEasingCurve::InOutQuad);
    
    auto* fadeIn = new QPropertyAnimation(fadeInEffect, "opacity", this);
    fadeIn->setDuration(300);
    fadeIn->setStartValue(0.0);
    fadeIn->setEndValue(1.0);
    fadeIn->setEasingCurve(QEasingCurve::InOutQuad);
    
    fadeOut->start(QAbstractAnimation::DeleteWhenStopped);
    fadeIn->start(QAbstractAnimation::DeleteWhenStopped);
    
    updateHeroIndicators();
    
    // Reset the auto-scroll timer
    if (m_heroCarouselTimer->isActive()) {
        m_heroCarouselTimer->start(5000);
    }
}

void MainWindow::updateHeroIndicators() {
    if (!m_heroIndicatorLayout) return;
    
    int count = m_heroStack ? m_heroStack->count() : 0;
    
    // Clear existing indicators
    QLayoutItem* child;
    while ((child = m_heroIndicatorLayout->takeAt(0)) != nullptr) {
        if (child->widget()) child->widget()->deleteLater();
        delete child;
    }
    
    if (count <= 1) return; // No indicators needed for 0 or 1 slides
    
    for (int i = 0; i < count; ++i) {
        QPushButton* bar = new QPushButton();
        bar->setFixedSize(i == m_currentHeroIndex ? 36 : 24, 4);
        bar->setCursor(Qt::PointingHandCursor);
        bar->setFlat(true);
        
        if (i == m_currentHeroIndex) {
            bar->setStyleSheet(
                "QPushButton { background: qlineargradient(x1:0, y1:0, x2:1, y2:0, "
                "stop:0 #bb86fc, stop:1 #6200ee); border: none; border-radius: 2px; }"
            );
        } else {
            bar->setStyleSheet(
                "QPushButton { background: rgba(255,255,255,60); border: none; border-radius: 2px; }"
                "QPushButton:hover { background: rgba(255,255,255,120); }"
            );
        }
        
        connect(bar, &QPushButton::clicked, this, [this, i]() {
            jumpToHeroSlide(i);
        });
        
        m_heroIndicatorLayout->addWidget(bar);
    }
}

void MainWindow::updateAmbientGlow() {
    int dr = m_targetGlowColor.red() - m_currentGlowColor.red();
    int dg = m_targetGlowColor.green() - m_currentGlowColor.green();
    int db = m_targetGlowColor.blue() - m_currentGlowColor.blue();
    
    if (qAbs(dr) < 2 && qAbs(dg) < 2 && qAbs(db) < 2) {
        m_currentGlowColor = m_targetGlowColor;
        m_glowTimer->stop();
    } else {
        m_currentGlowColor.setRed(m_currentGlowColor.red() + dr * 0.1);
        m_currentGlowColor.setGreen(m_currentGlowColor.green() + dg * 0.1);
        m_currentGlowColor.setBlue(m_currentGlowColor.blue() + db * 0.1);
    }
    update();
}

void MainWindow::paintEvent(QPaintEvent* event) {
    Q_UNUSED(event);
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing);
    
    // ΓöÇΓöÇ Pitch black background ΓöÇΓöÇ
    painter.fillRect(rect(), QColor(0, 0, 0));
    
    // ΓöÇΓöÇ Subtle dark blue secondary glow (top right) ΓöÇΓöÇ
    QRadialGradient glow1(rect().width() * 0.75, rect().height() * 0.25, rect().width() * 0.4);
    QColor darkBlue = Colors::toQColor(Colors::SECONDARY);
    darkBlue.setAlpha(12); // Extremely subtle light blue
    glow1.setColorAt(0, darkBlue);
    glow1.setColorAt(1, QColor(0, 0, 0, 0));
    painter.fillRect(rect(), glow1);
    
    // ΓöÇΓöÇ Subtle dark blue secondary glow (bottom left) ΓöÇΓöÇ
    QRadialGradient glow2(rect().width() * 0.2, rect().height() * 0.9, rect().width() * 0.5);
    QColor veryDarkBlue = Colors::toQColor(Colors::TERTIARY);
    veryDarkBlue.setAlpha(8);
    glow2.setColorAt(0, veryDarkBlue);
    glow2.setColorAt(1, QColor(0, 0, 0, 0));
    painter.fillRect(rect(), glow2);
}

void MainWindow::dragEnterEvent(QDragEnterEvent* event) {
    if (event->mimeData()->hasUrls()) {
        QList<QUrl> urls = event->mimeData()->urls();
        for (const QUrl& url : urls) {
            if (url.isLocalFile() && url.toLocalFile().endsWith(".lua", Qt::CaseInsensitive)) {
                event->acceptProposedAction();
                return;
            }
        }
    }
}

void MainWindow::dropEvent(QDropEvent* event) {
    QList<QUrl> urls = event->mimeData()->urls();
    if (urls.isEmpty()) return;

    QString pluginDir = Config::getSteamPluginDir();
    QDir dir(pluginDir);
    if (!dir.exists()) dir.mkpath(".");

    int count = 0;
    QString lastFile;

    for (const QUrl& url : urls) {
        if (url.isLocalFile()) {
            QString srcPath = url.toLocalFile();
            if (srcPath.endsWith(".lua", Qt::CaseInsensitive)) {
                QString fileName = QFileInfo(srcPath).fileName();
                QString destPath = dir.filePath(fileName);
                
                QFile::remove(destPath); // Overwrite
                if (QFile::copy(srcPath, destPath)) {
                    count++;
                    lastFile = fileName;
                }
            }
        }
    }

    if (count > 0) {
        m_statusLabel->setText(QString("Installed %1 patch%2").arg(count).arg(count > 1 ? "es" : ""));
        if (m_currentMode == AppMode::Library) {
            displayLibrary();
        } else {
            // Switch to library to show the new patch
            m_tabLibrary->animateClick();
        }
        event->acceptProposedAction();
    }
}

void MainWindow::initUI() {
    QWidget* central = new QWidget(this);
    setCentralWidget(central);
    
    QVBoxLayout* wrapperLayout = new QVBoxLayout(central);
    wrapperLayout->setContentsMargins(0, 0, 0, 0);
    wrapperLayout->setSpacing(0);

    // ΓöÇΓöÇ Custom Title Bar ΓöÇΓöÇ
    m_titleBar = new CustomTitleBar(this);
    connect(m_titleBar, &CustomTitleBar::minimizeRequested, this, &MainWindow::onTitleBarMinimize);
    connect(m_titleBar, &CustomTitleBar::maximizeRequested, this, &MainWindow::onTitleBarMaximize);
    connect(m_titleBar, &CustomTitleBar::closeRequested, this, &MainWindow::onTitleBarClose);
    wrapperLayout->addWidget(m_titleBar);

    QHBoxLayout* rootLayout = new QHBoxLayout();
    wrapperLayout->addLayout(rootLayout);
    rootLayout->setContentsMargins(0, 0, 0, 0);
    rootLayout->setSpacing(0);
    
    // ΓöÇΓöÇΓöÇΓöÇ Material Navigation Rail (Sidebar) ΓöÇΓöÇΓöÇΓöÇ
    m_sidebarWidget = new QWidget(this);
    m_sidebarWidget->setObjectName("sidebar");
    m_sidebarWidget->setFixedWidth(240);
    m_sidebarWidget->setAttribute(Qt::WA_StyledBackground);
    m_sidebarWidget->setAutoFillBackground(false);
    m_sidebarWidget->setStyleSheet(QString(
        "background-color: #000000; border-right: 1px solid rgba(255, 255, 255, 13);"
    ));
    m_sidebarWidget->installEventFilter(this);
    
    // Animation setup
    m_sidebarCollapseTimer = new QTimer(this);
    m_sidebarCollapseTimer->setSingleShot(true);
    connect(m_sidebarCollapseTimer, &QTimer::timeout, this, &MainWindow::collapseSidebarDelayed);
    
    // Inner container, now allows shrinking so buttons get narrow!
    QWidget* sidebarInner = new QWidget();
    sidebarInner->setMinimumWidth(60);
    sidebarInner->setStyleSheet("background: transparent; border: none;");
    
    QVBoxLayout* sidebarInnerLayout = new QVBoxLayout(sidebarInner);
    sidebarInnerLayout->setContentsMargins(16, 24, 16, 16);
    sidebarInnerLayout->setSpacing(12);
    
    QVBoxLayout* sidebarOuterLayout = new QVBoxLayout(m_sidebarWidget);
    sidebarOuterLayout->setContentsMargins(0, 0, 0, 0);
    sidebarOuterLayout->setAlignment(Qt::AlignLeft);
    sidebarOuterLayout->addWidget(sidebarInner);

    // ΓöÇΓöÇ App header with actual logo ΓöÇΓöÇ
    QHBoxLayout* headerLayout = new QHBoxLayout();
    headerLayout->setSpacing(12);
    
    QLabel* appIconLabel = new QLabel();
    appIconLabel->setFixedSize(36, 36);
    QString iconPath = Paths::getResourcePath("icon.png");
    if (QFile::exists(iconPath)) {
        QPixmap logoPixmap(iconPath);
        appIconLabel->setPixmap(logoPixmap.scaled(36, 36, Qt::KeepAspectRatio, Qt::SmoothTransformation));
    } else {
        // Fallback: draw a Material Flash icon
        appIconLabel->setStyleSheet(QString(
            "background: %1; border-radius: 10px; border: none;"
        ).arg(Colors::PRIMARY_CONTAINER));
    }
    appIconLabel->setStyleSheet(appIconLabel->styleSheet() + " border: none; background: transparent;");
    headerLayout->addWidget(appIconLabel);
    
    m_appTitleLabel = new QLabel("Lua Patcher");
    m_appTitleLabel->setStyleSheet(QString(
        "font-size: 20px; font-weight: 700; letter-spacing: -1px; color: %1; background: transparent; border: none; font-family: 'Oswald', sans-serif;"
    ).arg(Colors::ON_SURFACE));
    headerLayout->addWidget(m_appTitleLabel);
    headerLayout->addStretch();
    sidebarInnerLayout->addLayout(headerLayout);
    sidebarInnerLayout->addSpacing(30);
    
    // ΓöÇΓöÇ Section label ΓöÇΓöÇ
    m_navTitleLabel = new QLabel("NAVIGATION");
    m_navTitleLabel->setStyleSheet(QString(
        "font-size: 10px; font-weight: 600; color: %1; letter-spacing: 1px;"
        " background: transparent; border: none; padding-left: 4px; font-family: 'Oswald', sans-serif;"
    ).arg(Colors::OUTLINE));
    m_navTitleLabel->hide();
    sidebarInnerLayout->addWidget(m_navTitleLabel);
    sidebarInnerLayout->addSpacing(4);
    
    // m_appTitleLabel->hide();
    // m_navTitleLabel->hide();
    
    // Navigation tabs
    m_tabLua = new GlassButton(MaterialIcons::Home, " App Store", "", Colors::PRIMARY);
    m_tabLua->setFixedHeight(45);
    connect(m_tabLua, &QPushButton::clicked, this, [this](){ switchMode(AppMode::LuaPatcher); });
    sidebarInnerLayout->addWidget(m_tabLua);

    m_tabLibrary = new GlassButton(MaterialIcons::Library, " Library", "", Colors::PRIMARY);
    m_tabLibrary->setFixedHeight(45);
    connect(m_tabLibrary, &QPushButton::clicked, this, [this](){ switchMode(AppMode::Library); });
    sidebarInnerLayout->addWidget(m_tabLibrary);

    // ΓöÇΓöÇ Animated sidebar indicator bar ΓöÇΓöÇ
    m_sidebarIndicator = new QWidget(m_sidebarWidget);
    m_sidebarIndicator->setFixedSize(6, 28);
    m_sidebarIndicator->setStyleSheet("background: #EFECE3; border-radius: 2px;");
    m_sidebarIndicator->raise();
    
    m_indicatorAnimation = new QPropertyAnimation(m_sidebarIndicator, "pos", this);
    m_indicatorAnimation->setDuration(250);
    m_indicatorAnimation->setEasingCurve(QEasingCurve::OutCubic);

    sidebarInnerLayout->addStretch();

    m_btnRestart = new GlassButton(MaterialIcons::Steam, " Restart Steam", "", Colors::OUTLINE);
    m_btnRestart->setFixedHeight(45);
    connect(m_btnRestart, &QPushButton::clicked, this, &MainWindow::doRestart);
    sidebarInnerLayout->addWidget(m_btnRestart);
    sidebarInnerLayout->addSpacing(8);

    m_tabSettings = new GlassButton(MaterialIcons::Settings, " Settings", "", Colors::OUTLINE);
    m_tabSettings->setFixedHeight(45);
    connect(m_tabSettings, &QPushButton::clicked, this, [this](){ switchMode(AppMode::Settings); });
    sidebarInnerLayout->addWidget(m_tabSettings);
    sidebarInnerLayout->addSpacing(8);

    // Pro Pass Promo Card

    m_statusLabel = new QLabel("Initializing...");
    m_statusLabel->hide();
    
    sidebarInnerLayout->addSpacing(16);
    // Divider before version info
    QFrame* line2 = new QFrame();
    line2->setFrameShape(QFrame::HLine);
    line2->setFixedHeight(1);
    line2->setStyleSheet(QString("background: %1; border: none;").arg(Colors::OUTLINE_VARIANT));
    sidebarInnerLayout->addWidget(line2);
    sidebarInnerLayout->addSpacing(8);
    
    m_infoTitleLabel = new QLabel(QString("v%1<br>by <a href=\"https://github.com/sayedalimollah2602-prog\" style=\"color: %2; text-decoration: none;\">leVI</a> & <a href=\"https://github.com/raxnmint\" style=\"color: %2; text-decoration: none;\">raxnmint</a>").arg(Config::APP_VERSION).arg(Colors::ON_SURFACE_VARIANT));
    m_infoTitleLabel->setStyleSheet(QString("color: %1; font-size: 10px; font-weight: bold; font-family: 'Oswald', sans-serif; background: transparent; border: none;").arg(Colors::ON_SURFACE_VARIANT));
    m_infoTitleLabel->setAlignment(Qt::AlignCenter);
    m_infoTitleLabel->setTextFormat(Qt::RichText);
    m_infoTitleLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
    m_infoTitleLabel->setOpenExternalLinks(true);
    sidebarInnerLayout->addWidget(m_infoTitleLabel);
    
    m_infoTitleLabel->hide(); // Start collapsed
    
    m_infoTitleLabel->hide(); // Start collapsed
    
    rootLayout->addWidget(m_sidebarWidget);

    // ΓöÇΓöÇΓöÇΓöÇ Content Area ΓöÇΓöÇΓöÇΓöÇ
    QWidget* contentWidget = new QWidget();
    contentWidget->setStyleSheet("background: transparent;");
    QVBoxLayout* mainLayout = new QVBoxLayout(contentWidget);
    mainLayout->setContentsMargins(0, 40, 30, 20);
    mainLayout->setSpacing(20);
    
    // ΓöÇΓöÇ Top Bar (Search + Profile) ΓöÇΓöÇ
    QWidget* topBarWidget = new QWidget();
    QHBoxLayout* topBarLayout = new QHBoxLayout(topBarWidget);
    topBarLayout->setContentsMargins(0, 0, 0, 0);
    topBarLayout->setSpacing(16);
    
    // Search Container
    QWidget* searchContainer = new QWidget();
    searchContainer->setStyleSheet(QString(
        "background: rgba(255, 255, 255, 12); border-radius: 16px; border: 1px solid rgba(255, 255, 255, 25);"
    ));
    searchContainer->setFixedHeight(56);
    QHBoxLayout* searchLayout = new QHBoxLayout(searchContainer);
    searchLayout->setContentsMargins(12, 4, 12, 4);
    
    MaterialIconWidget* searchIconWidget = new MaterialIconWidget(
        MaterialIcons::Search, Colors::toQColor(Colors::ON_SURFACE_VARIANT), 32);
    searchLayout->addWidget(searchIconWidget);
    
    m_searchInput = new QLineEdit();
    m_searchInput->setPlaceholderText("Search thousands of games...");
    m_searchInput->setStyleSheet(QString(
        "QLineEdit { background: transparent; border: none; font-size: 15px; color: %1; padding: 0 8px; }"
        "QLineEdit:focus { border: none; background: transparent; }"
    ).arg(Colors::ON_SURFACE));
    connect(m_searchInput, &QLineEdit::textChanged, this, &MainWindow::onSearchChanged);
    searchLayout->addWidget(m_searchInput);
    
    MaterialIconButton* refreshBtn = new MaterialIconButton(
        MaterialIcons::Refresh, Colors::toQColor(Colors::ON_SURFACE_VARIANT), 36);
    connect(refreshBtn, &QPushButton::clicked, this, [this]() {
        if (m_searchInput->text().trimmed().isEmpty()) startSync(); else doSearch();
    });
    searchLayout->addWidget(refreshBtn);
    topBarLayout->addWidget(searchContainer, 1);
    
    // Top Bar Right Side (Notifications)
    QWidget* topActions = new QWidget();
    QHBoxLayout* topActionsLayout = new QHBoxLayout(topActions);
    topActionsLayout->setContentsMargins(0, 0, 0, 0);
    m_mainNotifBtn = new MaterialIconButton(MaterialIcons::Notifications, Colors::toQColor(Colors::ON_SURFACE_VARIANT), 40, topActions);
    connect(m_mainNotifBtn, &QPushButton::clicked, this, &MainWindow::onNotificationClicked);
    
    // Add badge
    m_mainNotifBadge = new QLabel(m_mainNotifBtn);
    m_mainNotifBadge->setFixedSize(16, 16);
    m_mainNotifBadge->setAlignment(Qt::AlignCenter);
    m_mainNotifBadge->move(20, 6);
    m_mainNotifBadge->setStyleSheet(
        "background: #E74C3C;"
        "color: white;"
        "font-size: 9px;"
        "font-weight: bold;"
        "font-family: 'Oswald', sans-serif;"
        "border-radius: 8px;"
        "border: none;"
    );
    m_mainNotifBadge->hide();
    
    topActionsLayout->addWidget(m_mainNotifBtn);
    topBarLayout->addWidget(topActions);
    
    mainLayout->addWidget(topBarWidget);
    
    // Stacked widget: page 0 = loading, page 1 = main content
    m_stack = new QStackedWidget();
    
    QWidget* pageLoading = new QWidget();
    QVBoxLayout* layLoading = new QVBoxLayout(pageLoading);
    layLoading->setAlignment(Qt::AlignCenter);
    m_spinner = new LoadingSpinner();
    layLoading->addWidget(m_spinner);
    m_stack->addWidget(pageLoading); // index 0
    
    // ΓöÇΓöÇ Main Content Page (Scrollable) ΓöÇΓöÇ
    m_mainScrollArea = new QScrollArea();
    m_mainScrollArea->setWidgetResizable(true);
    m_mainScrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    m_mainScrollArea->setFrameShape(QFrame::NoFrame);
    m_mainScrollArea->setStyleSheet(QString(
        "QScrollArea { background: transparent; border: none; }"
        "QScrollBar:vertical { background: %1; width: 8px; border-radius: 4px; }"
        "QScrollBar::handle:vertical { background: %2; border-radius: 4px; min-height: 30px; }"
        "QScrollBar::handle:vertical:hover { background: %3; }"
    ).arg("rgba(0,0,0,0)").arg(Colors::OUTLINE_VARIANT).arg(Colors::OUTLINE));
    
    m_mainScrollContainer = new QWidget();
    m_mainScrollContainer->setStyleSheet("background: transparent;");
    m_mainScrollLayout = new QVBoxLayout(m_mainScrollContainer);
    // Increased horizontal padding (15px) and spacing (10px) to perfectly fit the 175px game cards
    m_mainScrollLayout->setContentsMargins(15, 0, 15, 20);
    m_mainScrollLayout->setSpacing(10);
    
    // 1. Hero Stack ΓÇö holds up to 4 trending games, shows exactly one at a time
    QWidget* trendingHeader = new QWidget();
    QHBoxLayout* trendLay = new QHBoxLayout(trendingHeader);
    trendLay->setContentsMargins(0, 0, 0, 8);
    trendLay->setSpacing(8);
    QLabel* trendIcon = new QLabel();
    trendIcon->setPixmap(MaterialIcons::getPixmap(MaterialIcons::Flash, 28, QColor(255, 255, 255)));
    m_leadingTitlesLabel = new QLabel("<span style='color: #ffffff;'>TRENDING TITLES</span>");
    m_leadingTitlesLabel->setStyleSheet("font-size: 24px; font-weight: 800; padding-left: 0px; font-family: 'Oswald', sans-serif;");
    trendLay->addWidget(trendIcon);
    trendLay->addWidget(m_leadingTitlesLabel);
    trendLay->addStretch();
    
    m_heroStack = new QStackedWidget();
    m_heroStack->setFixedHeight(320);
    m_heroStack->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    m_heroStack->setStyleSheet("background: transparent; border: none; border-radius: 25px;");
    
    m_mainScrollLayout->addWidget(trendingHeader, 0, Qt::AlignLeft);
    m_mainScrollLayout->addWidget(m_heroStack);
    
    // Pagination indicators (Steam-style bars)
    m_heroIndicators = new QWidget();
    m_heroIndicators->setFixedHeight(20);
    m_heroIndicators->setMaximumWidth(1200);
    m_heroIndicators->setStyleSheet("background: transparent;");
    m_heroIndicatorLayout = new QHBoxLayout(m_heroIndicators);
    m_heroIndicatorLayout->setContentsMargins(0, 4, 0, 4);
    m_heroIndicatorLayout->setSpacing(6);
    m_heroIndicatorLayout->setAlignment(Qt::AlignCenter);
    m_mainScrollLayout->addWidget(m_heroIndicators, 0, Qt::AlignHCenter);
    
    // We can fade crossfade manually, but QStackedWidget doesn't officially animate between indices out-of-the-box.
    // However, it solves the scrolling 'halfway' visual bug and stays exactly fixed.
    m_heroCarouselTimer = new QTimer(this);
    connect(m_heroCarouselTimer, &QTimer::timeout, this, &MainWindow::scrollCarousel);
    
    
    // 2. Hidden trending container (still needed for trending card data)
    m_trendingTitle = new QLabel("Trending Games");
    m_trendingTitle->hide();
    m_mainScrollLayout->addWidget(m_trendingTitle);
    
    m_trendingScroll = new QScrollArea();
    m_trendingScroll->setWidgetResizable(true);
    m_trendingScroll->setFixedHeight(0);
    m_trendingScroll->hide();
    m_trendingScroll->setStyleSheet("background: transparent; border: none;");
    QWidget* trendContainer = new QWidget();
    m_trendingLayout = new QHBoxLayout(trendContainer);
    m_trendingLayout->setContentsMargins(0, 0, 0, 0);
    m_trendingLayout->setAlignment(Qt::AlignLeft);
    m_trendingScroll->setWidget(trendContainer);
    m_mainScrollLayout->addWidget(m_trendingScroll);
    
    // 3. All Games Grid Header
    m_gridHeaderWidget = new QWidget();
    QHBoxLayout* gridHeaderLayout = new QHBoxLayout(m_gridHeaderWidget);
    gridHeaderLayout->setContentsMargins(0, 0, 0, 0);

    gridHeaderLayout->setSpacing(8);

    QLabel* gridIcon = new QLabel();
    gridIcon->setPixmap(MaterialIcons::getPixmap(MaterialIcons::Gamepad, 28, QColor(255, 255, 255)));
    gridIcon->setStyleSheet("margin-bottom: 8px;");
    gridHeaderLayout->addWidget(gridIcon, 0, Qt::AlignBottom);

    m_gridTitleLabel = new QLabel("<span style='color: #ffffff;'>GAME STORE</span>");
    m_gridTitleLabel->setStyleSheet("font-size: 24px; font-weight: 800; padding-left: 0px; margin-bottom: 8px; font-family: 'Oswald', sans-serif;");
    gridHeaderLayout->addWidget(m_gridTitleLabel, 0, Qt::AlignBottom);
    gridHeaderLayout->addStretch();

    // Action Buttons for Library mode (hidden by default)
    m_removeSelectedBtn = new QPushButton("Remove Selected (0)");
    m_removeSelectedBtn->setStyleSheet(
        "QPushButton { background: rgba(255, 255, 255, 10); color: #888888; border: 1px solid rgba(255,255,255,20); border-radius: 6px; padding: 6px 16px; font-weight: 600; font-size: 13px; }"
        "QPushButton:enabled { background: rgba(207, 102, 121, 20); color: #cf6679; border-color: rgba(207,102,121,60); }"
        "QPushButton:enabled:hover { background: rgba(207, 102, 121, 40); border-color: rgba(207,102,121,100); }"
    );
    m_removeSelectedBtn->setCursor(Qt::PointingHandCursor);
    m_removeSelectedBtn->setEnabled(false);
    m_removeSelectedBtn->hide();

    m_clearLibraryBtn = new QPushButton("Clear Library");
    m_clearLibraryBtn->setStyleSheet(
        "QPushButton { background: rgba(207, 102, 121, 15); color: #cf6679; border: 1px solid rgba(207,102,121,40); border-radius: 6px; padding: 6px 16px; font-weight: 600; font-size: 13px; margin-left: 8px; }"
        "QPushButton:hover { background: rgba(207, 102, 121, 30); border-color: rgba(207,102,121,80); }"
    );
    m_clearLibraryBtn->setCursor(Qt::PointingHandCursor);
    m_clearLibraryBtn->hide();

    connect(m_removeSelectedBtn, &QPushButton::clicked, this, &MainWindow::onRemoveSelectedClicked);
    connect(m_clearLibraryBtn, &QPushButton::clicked, this, &MainWindow::onClearLibraryClicked);

    gridHeaderLayout->addWidget(m_removeSelectedBtn, 0, Qt::AlignBottom);
    gridHeaderLayout->addWidget(m_clearLibraryBtn, 0, Qt::AlignBottom);

    m_mainScrollLayout->addWidget(m_gridHeaderWidget);
    
    m_gridContainer = new QWidget();
    m_gridLayout = new QGridLayout(m_gridContainer);
    m_gridLayout->setContentsMargins(0, 0, 0, 0); 
    m_gridLayout->setSpacing(12); // Optimized for 190px cards
    m_gridLayout->setAlignment(Qt::AlignHCenter | Qt::AlignTop);
    m_mainScrollLayout->addWidget(m_gridContainer);
    
    m_mainScrollArea->setWidget(m_mainScrollContainer);
    connect(m_mainScrollArea->verticalScrollBar(), &QScrollBar::valueChanged,
            this, [this]() {
        // Debounce scroll-triggered thumbnail loads to avoid flooding
        if (!m_thumbDebounceTimer) {
            m_thumbDebounceTimer = new QTimer(this);
            m_thumbDebounceTimer->setSingleShot(true);
            m_thumbDebounceTimer->setInterval(100);
            connect(m_thumbDebounceTimer, &QTimer::timeout,
                    this, &MainWindow::loadVisibleThumbnails);
        }
        m_thumbDebounceTimer->start();
    });
    
    m_stack->addWidget(m_mainScrollArea); // index 1
    
    // 4. Settings Page
    QWidget* settingsWidget = new QWidget();
    settingsWidget->setStyleSheet("background: transparent;");
    QVBoxLayout* settingsLayout = new QVBoxLayout(settingsWidget);
    settingsLayout->setAlignment(Qt::AlignTop);
    
    QLabel* settingsTitle = new QLabel("Settings");
    settingsTitle->setStyleSheet("font-size: 24px; font-weight: bold; color: white;");
    settingsLayout->addWidget(settingsTitle);
    settingsLayout->addSpacing(20);
    
    QLabel* pathLabel = new QLabel("Steam Plugin Folder Path:");
    pathLabel->setStyleSheet("color: rgba(255,255,255,160); font-size: 14px;");
    settingsLayout->addWidget(pathLabel);
    
    QHBoxLayout* pathLayout = new QHBoxLayout();
    QLineEdit* pathInput = new QLineEdit(Config::getSteamPluginDir());
    pathInput->setStyleSheet("background: rgba(8, 10, 18, 150); border: 1px solid rgba(255,255,255,25); color: white; padding: 10px; border-radius: 6px; font-size: 14px;");
    pathInput->setReadOnly(true);
    pathLayout->addWidget(pathInput);
    
    GlassButton* browseBtn = new GlassButton(MaterialIcons::Search, " Browse...", "", Colors::PRIMARY);
    browseBtn->setFixedHeight(44);
    connect(browseBtn, &QPushButton::clicked, this, [this, pathInput]() {
        QPointer<MainWindow> guard(this);
        QString dir = QFileDialog::getExistingDirectory(this, "Select Steam Plugin Directory", pathInput->text());
        if (!guard || dir.isEmpty()) return;
        
        // Unify separators visually
        pathInput->setText(dir);
        QString appDataPath = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);
        QString settingsPath = appDataPath + "/settings.ini";
        QSettings settings(settingsPath, QSettings::IniFormat);
        settings.setValue("PluginDir", dir);
    });
    pathLayout->addWidget(browseBtn);
    settingsLayout->addLayout(pathLayout);
    settingsLayout->addSpacing(30);
    
    // ΓöÇΓöÇ Steam Patch Section ΓöÇΓöÇ
    QLabel* patchSectionLabel = new QLabel("Steam Patch");
    patchSectionLabel->setStyleSheet("font-size: 18px; font-weight: bold; color: white;");
    settingsLayout->addWidget(patchSectionLabel);
    settingsLayout->addSpacing(8);
    
    QLabel* patchDescLabel = new QLabel(
        "Install the Steam unlock patch directly. This places the required file into your "
        "Steam directory so games and DLCs can be unlocked without needing a separate tool.");
    patchDescLabel->setStyleSheet("color: rgba(255,255,255,120); font-size: 13px;");
    patchDescLabel->setWordWrap(true);
    settingsLayout->addWidget(patchDescLabel);
    settingsLayout->addSpacing(12);
    
    // Status label for patch
    QLabel* patchStatusLabel = new QLabel("");
    patchStatusLabel->setStyleSheet("color: rgba(255,255,255,140); font-size: 13px;");
    patchStatusLabel->setWordWrap(true);
    patchStatusLabel->hide();
    
    // Check current patch status
    QString steamDir = Config::getSteamDir();
    bool alreadyPatched = false;
    if (!steamDir.isEmpty()) {
        QString existingDll = QDir(steamDir).filePath("xinput1_4.dll");
        alreadyPatched = QFile::exists(existingDll);
    }
    
    GlassButton* patchBtn = new GlassButton(
        MaterialIcons::Flash, 
        alreadyPatched ? " Re-Patch Steam" : " Patch Steam", 
        "", 
        alreadyPatched ? Colors::OUTLINE : "#2ECC71"
    );
    patchBtn->setFixedHeight(44);
    
    // Unpatch button
    GlassButton* unpatchBtn = new GlassButton(MaterialIcons::Delete, " Remove Patch", "", "#E74C3C");
    unpatchBtn->setFixedHeight(44);
    unpatchBtn->setVisible(alreadyPatched);
    
    connect(patchBtn, &QPushButton::clicked, this, [this, patchBtn, unpatchBtn, patchStatusLabel]() {
        patchBtn->setEnabled(false);
        patchBtn->setText(" Patching...");
        patchStatusLabel->setStyleSheet("color: rgba(255,255,255,140); font-size: 13px;");
        patchStatusLabel->setText("Starting Steam patch...");
        patchStatusLabel->show();
        
        m_steamPatchWorker = new SteamPatchWorker(this);
        QPointer<MainWindow> guard(this);
        QPointer<GlassButton> safePatchBtn(patchBtn);
        QPointer<GlassButton> safeUnpatchBtn(unpatchBtn);
        QPointer<QLabel> safeStatus(patchStatusLabel);
        
        connect(m_steamPatchWorker, &SteamPatchWorker::log, this, [safeStatus](QString msg, QString level) {
            if (!safeStatus) return;
            if (level == "ERROR") {
                safeStatus->setStyleSheet("color: #E74C3C; font-size: 13px;");
            } else if (level == "SUCCESS") {
                safeStatus->setStyleSheet("color: #2ECC71; font-size: 13px;");
            } else {
                safeStatus->setStyleSheet("color: rgba(255,255,255,140); font-size: 13px;");
            }
            safeStatus->setText(msg);
        });
        
        connect(m_steamPatchWorker, &SteamPatchWorker::finished, this, [guard, safePatchBtn, safeUnpatchBtn, safeStatus](QString msg) {
            if (!guard) return;
            if (safePatchBtn) {
                safePatchBtn->setEnabled(true);
                safePatchBtn->setText(" Re-Patch Steam");
            }
            if (safeUnpatchBtn) safeUnpatchBtn->setVisible(true);
            if (safeStatus) {
                safeStatus->setStyleSheet("color: #2ECC71; font-size: 13px; font-weight: bold;");
                safeStatus->setText(msg);
            }
        });
        
        connect(m_steamPatchWorker, &SteamPatchWorker::error, this, [guard, safePatchBtn, safeStatus](QString err) {
            if (!guard) return;
            if (safePatchBtn) {
                safePatchBtn->setEnabled(true);
                safePatchBtn->setText(" Patch Steam");
            }
            if (safeStatus) {
                safeStatus->setStyleSheet("color: #E74C3C; font-size: 13px;");
                safeStatus->setText("Error: " + err);
            }
        });
        
        connect(m_steamPatchWorker, &QThread::finished, m_steamPatchWorker, &QObject::deleteLater);
        m_steamPatchWorker->start();
    });
    
    connect(unpatchBtn, &QPushButton::clicked, this, [this, patchBtn, unpatchBtn, patchStatusLabel]() {
        QString steamDir = Config::getSteamDir();
        if (steamDir.isEmpty()) {
            patchStatusLabel->setStyleSheet("color: #E74C3C; font-size: 13px;");
            patchStatusLabel->setText("Steam directory not found.");
            patchStatusLabel->show();
            return;
        }
        QString dllPath = QDir(steamDir).filePath("xinput1_4.dll");
        if (QFile::exists(dllPath)) {
            if (QFile::remove(dllPath)) {
                patchStatusLabel->setStyleSheet("color: #2ECC71; font-size: 13px; font-weight: bold;");
                patchStatusLabel->setText("Patch removed successfully. Restart Steam.");
                patchBtn->setText(" Patch Steam");
                unpatchBtn->setVisible(false);
            } else {
                patchStatusLabel->setStyleSheet("color: #E74C3C; font-size: 13px;");
                patchStatusLabel->setText("Failed to remove patch. Close Steam first.");
            }
        } else {
            patchStatusLabel->setText("No patch found to remove.");
            unpatchBtn->setVisible(false);
        }
        patchStatusLabel->show();
    });
    
    QHBoxLayout* patchBtnLayout = new QHBoxLayout();
    patchBtnLayout->addWidget(patchBtn);
    patchBtnLayout->addWidget(unpatchBtn);
    patchBtnLayout->addStretch();
    settingsLayout->addLayout(patchBtnLayout);
    settingsLayout->addSpacing(4);
    settingsLayout->addWidget(patchStatusLabel);
    settingsLayout->addSpacing(30);
    
    // Logout Button
    GlassButton* logoutBtn = new GlassButton(MaterialIcons::Logout, " Log Out", "", "#E74C3C");
    logoutBtn->setFixedHeight(44);
    connect(logoutBtn, &QPushButton::clicked, this, [this]() {
        QString appDataPath = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);
        QSettings settings(appDataPath + "/settings.ini", QSettings::IniFormat);
        settings.remove("username");
        settings.remove("isGuest");
        settings.remove("userData");
        settings.sync();
        
        QProcess::startDetached(QApplication::applicationFilePath(), QStringList());
        QApplication::quit();
    });
    settingsLayout->addWidget(logoutBtn);
    
    settingsLayout->addStretch();
    m_stack->addWidget(settingsWidget); // index 2
    
    // index 3: Game Details Page
    m_gameDetailsPage = new GameDetailsPage(m_networkManager, this);
    connect(m_gameDetailsPage, &GameDetailsPage::backClicked, this, &MainWindow::onGameDetailsBack);
    connect(m_gameDetailsPage, &GameDetailsPage::addToLibraryClicked, this, &MainWindow::onInstallFromDetails);
    m_stack->addWidget(m_gameDetailsPage); // index 3
    
    // index 4: Chat Page
    m_chatPage = new ChatPage(m_username, "", "", m_networkManager, this);
    connect(m_chatPage, &ChatPage::backRequested, this, &MainWindow::onChatBack);
    m_stack->addWidget(m_chatPage); // index 4
    
    mainLayout->addWidget(m_stack);
    
    // Progress bar - Material linear progress
    m_progress = new QProgressBar();
    m_progress->setFixedHeight(4);
    m_progress->setTextVisible(false);
    m_progress->setStyleSheet(QString(
        "QProgressBar { background: %1; border-radius: 2px; }"
        "QProgressBar::chunk { background: %2; border-radius: 2px; }"
    ).arg(Colors::SURFACE_VARIANT).arg(Colors::PRIMARY));
    m_progress->hide();
    mainLayout->addWidget(m_progress);
    
    // ΓöÇΓöÇRight Panel ΓöÇΓöÇ
    m_rightPanelWidget = new QWidget();
    m_rightPanelWidget->setFixedWidth(280);
    m_rightPanelWidget->setStyleSheet("background: rgba(255, 255, 255, 5); border-left: 1px solid rgba(255, 255, 255, 13);");
    QVBoxLayout* rightLayout = new QVBoxLayout(m_rightPanelWidget);
    rightLayout->setContentsMargins(16, 20, 16, 20);
    rightLayout->setSpacing(10);

    // ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ
    // Top Right Profile Capsule ΓÇö Pill-shaped glass widget
    // ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ
    m_topProfileWidget = new QWidget();
    m_topProfileWidget->setFixedHeight(52);
    m_topProfileWidget->setMinimumWidth(160);
    m_topProfileWidget->setMaximumWidth(260);
    m_topProfileWidget->setObjectName("profileCapsule");
    m_topProfileWidget->setCursor(Qt::PointingHandCursor);
    m_topProfileWidget->setStyleSheet(
        "QWidget#profileCapsule {"
        "  background: rgba(15, 20, 30, 0.55);"
        "  border: 1px solid rgba(255, 255, 255, 0.08);"
        "  border-radius: 26px;"  // Fully rounded pill
        "}"
        "QWidget#profileCapsule:hover {"
        "  background: rgba(30, 45, 70, 0.7);"
        "  border: 1px solid rgba(143, 171, 212, 0.25);"
        "}"
    );
    m_topProfileWidget->installEventFilter(this);

    QHBoxLayout* capsuleLayout = new QHBoxLayout(m_topProfileWidget);
    capsuleLayout->setContentsMargins(6, 6, 16, 6);
    capsuleLayout->setSpacing(10);

    // ΓöÇΓöÇ Avatar with clean ring + online dot ΓöÇΓöÇ
    int avSz = 40;
    QWidget* avatarContainer = new QWidget();
    avatarContainer->setFixedSize(avSz, avSz);
    avatarContainer->setStyleSheet("background: transparent; border: none; margin: 0; padding: 0;");

    QPixmap avatarPix(avSz, avSz);
    avatarPix.fill(Qt::transparent);
    QPainter ap(&avatarPix);
    ap.setRenderHint(QPainter::Antialiasing);

    // Soft ring border
    ap.setPen(QPen(QColor(143, 171, 212, 80), 1.5));
    ap.setBrush(Qt::NoBrush);
    ap.drawEllipse(QRectF(1, 1, avSz - 2, avSz - 2));

    // Inner filled circle (avatar background)
    ap.setPen(Qt::NoPen);
    ap.setBrush(QColor("#4A6FA5"));
    ap.drawEllipse(QRectF(3, 3, avSz - 6, avSz - 6));

    // Letter initial
    ap.setPen(QColor(255, 255, 255, 240));
    ap.setFont(QFont("Segoe UI", 14, QFont::Bold));
    ap.drawText(QRectF(3, 3, avSz - 6, avSz - 6), Qt::AlignCenter, m_username.isEmpty() ? "U" : m_username.left(1).toUpper());

    // Green online dot (bottom-right)
    int dotSz = 10;
    int dotX = avSz - dotSz - 1;
    int dotY = avSz - dotSz - 1;
    ap.setBrush(QColor(15, 20, 30));
    ap.setPen(Qt::NoPen);
    ap.drawEllipse(dotX - 2, dotY - 2, dotSz + 4, dotSz + 4);
    ap.setBrush(QColor("#2ECC71"));
    ap.drawEllipse(dotX, dotY, dotSz, dotSz);

    ap.end();

    m_sidebarAvatarLabel = new QLabel(avatarContainer);
    m_sidebarAvatarLabel->setStyleSheet("background: transparent; border: none; margin: 0; padding: 0;");
    m_sidebarAvatarLabel->setPixmap(avatarPix);
    m_sidebarAvatarLabel->setGeometry(0, 0, avSz, avSz);
    avatarContainer->setAttribute(Qt::WA_TransparentForMouseEvents);
    capsuleLayout->addWidget(avatarContainer);

    // ΓöÇΓöÇ Username ΓöÇΓöÇ
    m_topUsernameLabel = new QLabel(m_username.isEmpty() ? "User" : m_username);
    m_topUsernameLabel->setStyleSheet(
        "font-size: 14px; font-weight: 700; color: #EAEEF3;"
        "background: transparent; font-family: 'Oswald', sans-serif;"
        "letter-spacing: 0.3px;"
    );
    capsuleLayout->addWidget(m_topUsernameLabel);
    capsuleLayout->addStretch();

    rightLayout->addWidget(m_topProfileWidget);

    // Ensure ALL children are mouse-transparent so the capsule catches the click
    for (auto* child : m_topProfileWidget->findChildren<QWidget*>()) {
        child->setAttribute(Qt::WA_TransparentForMouseEvents);
    }


    // ΓöÇΓöÇ FRIENDS SECTION ΓöÇΓöÇ
    QLabel* friendsHeader = new QLabel("FRIENDS (0 ONLINE)");
    friendsHeader->setObjectName("friendsHeader");
    friendsHeader->setStyleSheet("font-size: 11px; font-weight: 800; letter-spacing: 1.2px; color: #8FABD4; margin-top: 15px; margin-bottom: 5px;");
    rightLayout->addWidget(friendsHeader);

    // Scrollable Friends Area
    QScrollArea* friendsScroll = new QScrollArea();
    friendsScroll->setWidgetResizable(true);
    friendsScroll->setFrameShape(QFrame::NoFrame);
    friendsScroll->setStyleSheet("background: transparent; border: none;");
    
    m_friendsContainer = new QWidget();
    m_friendsContainer->setObjectName("friendsContainer");
    m_friendsContainer->setStyleSheet("background: transparent;");
    m_friendsLayout = new QVBoxLayout(m_friendsContainer);
    m_friendsLayout->setContentsMargins(0, 0, 0, 0);
    m_friendsLayout->setSpacing(12);
    m_friendsLayout->setAlignment(Qt::AlignTop);
    
    // Placeholder if no friends
    QLabel* noFriendsLabel = new QLabel("No friends yet. Add some!");
    noFriendsLabel->setObjectName("noFriendsLabel");
    noFriendsLabel->setStyleSheet("color: rgba(255, 255, 255, 0.4); font-size: 12px; font-style: italic; margin: 20px;");
    noFriendsLabel->setAlignment(Qt::AlignCenter);
    m_friendsLayout->addWidget(noFriendsLabel);

    friendsScroll->setWidget(m_friendsContainer);
    rightLayout->addWidget(friendsScroll, 1); // Give it stretch

    // ΓöÇΓöÇ BOTTOM ADD FRIEND BUTTON ΓöÇΓöÇ
    QPushButton* addFriendBtn = new QPushButton("    ADD FRIEND");
    addFriendBtn->setFixedHeight(45);
    addFriendBtn->setCursor(Qt::PointingHandCursor);
    addFriendBtn->setStyleSheet(
        "QPushButton { "
        "  background: #111821; "
        "  border: 1px solid rgba(255, 255, 255, 0.1); "
        "  border-radius: 22px; "
        "  color: white; "
        "  font-weight: bold; "
        "  font-size: 13px; "
        "  text-align: center; "
        "} "
        "QPushButton:hover { "
        "  background: #1A2432; "
        "  border: 1px solid rgba(255, 255, 255, 0.2); "
        "}"
    );
    
    // Add icon to the button
    QHBoxLayout* btnLayout = new QHBoxLayout(addFriendBtn);
    btnLayout->setContentsMargins(15, 0, 0, 0);
    QLabel* btnIcon = new QLabel();
    btnIcon->setPixmap(QIcon(":/icons/add_friend.png").pixmap(18, 18)); // Fallback if no icon
    if (btnIcon->pixmap().isNull()) {
        btnIcon->setText("+");
        btnIcon->setStyleSheet("color: white; font-size: 18px; font-weight: bold;");
    }
    btnLayout->addWidget(btnIcon, 0, Qt::AlignVCenter | Qt::AlignLeft);
    btnLayout->addStretch();
    
    connect(addFriendBtn, &QPushButton::clicked, this, [this]() {
        showBlurOverlay();
        AddFriendDialog* dialog = new AddFriendDialog(m_username, m_networkManager, this);
        dialog->move(geometry().center() - dialog->rect().center());
        QPointer<MainWindow> guard(this);
        dialog->exec();
        if (guard) guard->hideBlurOverlay();
    });
    rightLayout->addWidget(addFriendBtn);

    rootLayout->addWidget(contentWidget);
    rootLayout->addWidget(m_rightPanelWidget);
    m_terminalDialog = new TerminalDialog(this);
    updateModeUI();
    // Defer indicator positioning until layout is finalized (mapTo needs valid geometry)
    QTimer::singleShot(100, this, [this]() {
        if (m_sidebarIndicator && m_tabLua) {
            QPoint tabPos = m_tabLua->mapTo(m_sidebarWidget, QPoint(0, 0));
            int indicatorY = tabPos.y() + (m_tabLua->height() - m_sidebarIndicator->height()) / 2;
            m_sidebarIndicator->move(6, indicatorY);
            m_sidebarIndicator->show();
        }
    });
}

void MainWindow::clearGameCards() {
    m_selectedCard = nullptr;
    
    // Reset pending thumbnail queue
    m_pendingThumbnailIds.clear();
    m_activeThumbnailCount = 0;
    
    // Clear trending layout
    while (QLayoutItem* item = m_trendingLayout->takeAt(0)) {
        if (QWidget* widget = item->widget()) {
            widget->hide();
            widget->deleteLater();
        }
        delete item;
    }
    
    // Clear grid layout
    while (QLayoutItem* item = m_gridLayout->takeAt(0)) {
        if (QWidget* widget = item->widget()) {
            widget->hide();
            widget->deleteLater();
        }
        delete item;
    }
    
    m_gameCards.clear();
}

void MainWindow::displayRandomGames() {
    clearGameCards();
    m_selectedGame.clear();
    cancelNameFetches();
    m_pendingNameFetchIds.clear();

    if (m_supportedGames.isEmpty()) return;

    // Show Home-specific components
    if (m_leadingTitlesLabel) m_leadingTitlesLabel->show();
    if (m_heroStack) m_heroStack->show();
    m_mainScrollArea->show();
    
    // Update grid title
    m_gridTitleLabel->setText("<span style='color: #ffffff;'>GAME STORE</span>");

    if (m_removeSelectedBtn) m_removeSelectedBtn->hide();
    if (m_clearLibraryBtn) m_clearLibraryBtn->hide();

    // Build a set of supported IDs for fast lookup
    QSet<QString> supportedIds;
    for (const auto& g : m_supportedGames) supportedIds.insert(g.id);

    // Featured trending games for hero banner carousel
    QList<GameInfo> carouselGames;
    if (!m_trendingAppIds.isEmpty()) {
        for (const QString& tid : m_trendingAppIds) {
            if (!supportedIds.contains(tid)) continue;
            for (const auto& g : m_supportedGames) {
                if (g.id == tid) { carouselGames.append(g); break; }
            }
            if (carouselGames.size() >= 5) break; // Fetch up to 5 candidates to avoid burst
        }
    }
    
    // Fallback: pick random supported games
    if (carouselGames.size() < 5 && !m_supportedGames.isEmpty()) {
        QList<GameInfo> randGames = m_supportedGames;
        auto *rng = QRandomGenerator::global();
        for (int i = randGames.size() - 1; i > 0; --i) {
            randGames.swapItemsAt(i, rng->bounded(i + 1));
        }
        for (int i = 0; i < qMin(5 - carouselGames.size(), (int)randGames.size()); ++i) {
            carouselGames.append(randGames[i]);
        }
    }
    
    if (m_heroCarouselTimer) m_heroCarouselTimer->stop();

    // Clear old carousel slides
    while (m_heroStack->count() > 0) {
        QWidget* w = m_heroStack->widget(0);
        m_heroStack->removeWidget(w);
        w->deleteLater();
    }
    m_currentHeroIndex = 0;
    
    // Build new slides
    for (const GameInfo& game : carouselGames) {
        QString featuredId = game.id;
        QString featuredName = game.name;
        if (featuredName.isEmpty() || featuredName == game.id) {
            featuredName = m_nameCache.contains(game.id) ? m_nameCache[game.id] : game.id;
        }
        
        QWidget* slide = new QWidget();
        slide->setFixedHeight(320);
        slide->setCursor(Qt::PointingHandCursor);
        slide->setProperty("isHeroSlide", true);
        slide->setProperty("gameAppId", featuredId);
        slide->installEventFilter(this);
        
        QVBoxLayout* slideLayout = new QVBoxLayout(slide);
        slideLayout->setContentsMargins(0, 0, 0, 0);
        
        // Background image layer (Main container for the slide)
        HeroBannerWidget* imgLabel = new HeroBannerWidget();
        imgLabel->setFixedHeight(320);
        slideLayout->addWidget(imgLabel);
        
        // Gradient scrim overlay (vertical: transparent top → dark bottom)
        // Must be QFrame to support stylesheet background colors naturally
        QFrame* overlay = new QFrame(imgLabel);
        overlay->setObjectName("heroOverlay");
        overlay->setStyleSheet(
            "#heroOverlay {"
            "  background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 rgba(0,0,0,0), stop:0.5 rgba(0,0,0,30), stop:1 rgba(0,0,0,217));"
            "  border-radius: 12px;"
            "}"
        );
        
        // Make overlay exactly cover the imgLabel
        QVBoxLayout* imgLayout = new QVBoxLayout(imgLabel);
        imgLayout->setContentsMargins(0, 0, 0, 0);
        imgLayout->addWidget(overlay);
        
        // Text content anchored to bottom-left
        QVBoxLayout* heroLayout = new QVBoxLayout(overlay);
        heroLayout->setContentsMargins(35, 20, 35, 25);
        heroLayout->setSpacing(0);
        
        // Push everything to the bottom
        heroLayout->addStretch(1);
        
        // Game title - large bold white text
        QLabel* nameLbl = new QLabel(featuredName.toUpper());
        nameLbl->setStyleSheet(
            "font-size: 42px; font-weight: 900; color: #FFFFFF; background: transparent; border: none;"
            " font-family: 'Oswald', sans-serif; letter-spacing: -1px;"
        );
        nameLbl->setWordWrap(true);
        nameLbl->setMaximumWidth(700);
        heroLayout->addWidget(nameLbl);
        
        // Description - fetched dynamically from Steam API
        QLabel* descLbl = new QLabel(QString("Discover community patches and enhancements for %1.").arg(featuredName));
        descLbl->setStyleSheet(
            "font-size: 16px; font-weight: 500; color: rgba(255, 255, 255, 180); background: transparent; border: none;"
            " font-family: 'Oswald', sans-serif; margin-top: 8px; margin-bottom: 2px;"
        );
        descLbl->setWordWrap(true);
        descLbl->setMaximumWidth(650);
        heroLayout->addWidget(descLbl);
        
        // Fetch real description from Steam Store API
        QPointer<QLabel> safeDesc(descLbl);
        QString descUrl = QString("https://store.steampowered.com/api/appdetails?appids=%1&l=english").arg(featuredId);
        QNetworkReply* descReply = m_networkManager->get(QNetworkRequest(QUrl(descUrl)));
        connect(descReply, &QNetworkReply::finished, this, [safeDesc, descReply, featuredId]() {
            descReply->deleteLater();
            if (!safeDesc || descReply->error() != QNetworkReply::NoError) return;
            
            QJsonDocument doc = QJsonDocument::fromJson(descReply->readAll());
            QJsonObject appData = doc.object()[featuredId].toObject()["data"].toObject();
            QString shortDesc = appData["short_description"].toString();
            
            if (!shortDesc.isEmpty() && safeDesc) {
                // Truncate to ~120 chars for a clean 2-line display
                if (shortDesc.length() > 120) {
                    shortDesc = shortDesc.left(117) + "...";
                }
                safeDesc->setText(shortDesc);
            }
        });
        
        // Subtitle with App ID
        QLabel* subtitleLbl = new QLabel(QString("App ID: %1").arg(featuredId));
        subtitleLbl->setStyleSheet(
            "font-size: 14px; font-weight: 500; color: #8FABD4; background: transparent; border: none;"
            " font-family: 'Oswald', sans-serif; margin-top: 6px;"
        );
        heroLayout->addWidget(subtitleLbl);
        m_heroStack->addWidget(slide);
        updateHeroIndicators();

        // Fetch high-quality hero image for background, with fallback to low-res header
        QString heroUrl = QString("https://cdn.akamai.steamstatic.com/steam/apps/%1/library_hero.jpg").arg(featuredId);
        QNetworkRequest req{QUrl(heroUrl)};
        req.setHeader(QNetworkRequest::UserAgentHeader, "SteamLuaPatcher/2.0");
        req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
        req.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
        QNetworkReply* heroReply = m_networkManager->get(req);
        
        QPointer<HeroBannerWidget> safeImgLabel(imgLabel);
        QPointer<QWidget> safeSlide(slide);
        auto* nm = m_networkManager;
        connect(heroReply, &QNetworkReply::finished, this, [this, heroReply, safeImgLabel, nm, featuredId, safeSlide]() {
            heroReply->deleteLater();
            bool success = false;
            if (heroReply->error() == QNetworkReply::NoError && safeImgLabel) {
                QPixmap rawPix;
                if (rawPix.loadFromData(heroReply->readAll())) {
                    safeImgLabel->setPixmap(rawPix);
                    success = true;
                }
            }
            if (!success && safeImgLabel && nm) {
                QString fallbackUrl = QString("https://cdn.akamai.steamstatic.com/steam/apps/%1/header.jpg").arg(featuredId);
                QNetworkRequest fallbackReq{QUrl(fallbackUrl)};
                fallbackReq.setHeader(QNetworkRequest::UserAgentHeader, "SteamLuaPatcher/2.0");
                fallbackReq.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
                fallbackReq.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
                QNetworkReply* fallbackReply = nm->get(fallbackReq);
                connect(fallbackReply, &QNetworkReply::finished, this, [this, fallbackReply, safeImgLabel, safeSlide]() {
                    fallbackReply->deleteLater();
                    bool internalSuccess = false;
                    if (fallbackReply->error() == QNetworkReply::NoError && safeImgLabel) {
                        QPixmap rawPix;
                        if (rawPix.loadFromData(fallbackReply->readAll())) {
                            safeImgLabel->setPixmap(rawPix);
                            internalSuccess = true;
                        }
                    }
                    
                    if (!internalSuccess && safeSlide) {
                         m_heroStack->removeWidget(safeSlide);
                         safeSlide->deleteLater();
                         updateHeroIndicators();
                    }
                });
            } else if (!success && safeSlide) {
                 m_heroStack->removeWidget(safeSlide);
                 safeSlide->deleteLater();
                 updateHeroIndicators();
            }
        });



    }
    
    // Start slider timer to rotate every 5 seconds
    m_heroCarouselTimer->start(5000);

    // All Games Grid ΓÇö shuffled
    QList<GameInfo> shuffled = m_supportedGames;
    auto *rng = QRandomGenerator::global();
    for (int i = shuffled.size() - 1; i > 0; --i) {
        int j = rng->bounded(i + 1);
        shuffled.swapItemsAt(i, j);
    }
    
    int gridIdx = 0;
    for (const GameInfo& game : shuffled) {
        if (gridIdx >= 36) break;
        
        QMap<QString, QString> cd;
        cd["name"] = game.name;
        cd["appid"] = game.id;
        cd["supported"] = "true";
        cd["hasFix"] = game.hasFix ? "true" : "false";

        if (cd["name"].isEmpty() || cd["name"] == game.id) {
            cd["name"] = m_nameCache.contains(game.id) ? m_nameCache[game.id] : "Loading...";
        }
        if (cd["name"] == "Loading...") m_pendingNameFetchIds.append(game.id);

        GameCard* card = new GameCard(m_gridLayout->parentWidget());
        card->setGameData(cd);
        connect(card, &GameCard::clicked, this, &MainWindow::onCardClicked);
        m_gameCards.append(card);

        if (m_thumbnailCache.contains(game.id)) card->setThumbnail(m_thumbnailCache[game.id]);
        gridIdx++;
    }

    rearrangeGameGrid(true); // Dynamically layout the grid
    QTimer::singleShot(50, this, &MainWindow::loadVisibleThumbnails);
    if (!m_pendingNameFetchIds.isEmpty()) startBatchNameFetch();

    m_statusLabel->setText(QString("Home: %1 games discovered").arg(m_gameCards.count()));
    m_stack->setCurrentIndex(1);
    m_spinner->stop();
}

// ---- Fetch trending games from SteamSpy ----
void MainWindow::fetchTrendingGames() {
    if (!m_networkManager) return;
    
    QUrl url("https://steamspy.com/api.php?request=top100in2weeks");
    QNetworkRequest req(url);
    req.setHeader(QNetworkRequest::UserAgentHeader, "SteamLuaPatcher/2.0");
    
    QNetworkReply* reply = m_networkManager->get(req);
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        onTrendingFetched(reply);
    });
}

void MainWindow::onTrendingFetched(QNetworkReply* reply) {
    reply->deleteLater();
    if (reply->error() != QNetworkReply::NoError) return;
    
    QJsonObject obj = QJsonDocument::fromJson(reply->readAll()).object();
    m_trendingAppIds.clear();
    
    // SteamSpy returns {appid: {data...}, ...} ΓÇö keys are the app IDs
    for (auto it = obj.begin(); it != obj.end(); ++it) {
        m_trendingAppIds.append(it.key());
    }
    
    // Shuffle the Trending list using the current Date!
    // This perfectly creates a "Game of the Day" rotating banner logic.
    if (!m_trendingAppIds.isEmpty()) {
        QRandomGenerator dailyRng(QDate::currentDate().dayOfYear() + QDate::currentDate().year());
        for (int i = m_trendingAppIds.size() - 1; i > 0; --i) {
            m_trendingAppIds.swapItemsAt(i, dailyRng.bounded(i + 1));
        }
    }
    
    // Refresh the display if we're on the home screen
    if (m_currentMode == AppMode::LuaPatcher && m_searchInput->text().trimmed().isEmpty()) {
        displayRandomGames();
    }
}

// ---- Display installed patches (Library) ----
void MainWindow::displayLibrary() {
    clearGameCards();
    m_selectedGame.clear();
    
    // Hide Home-specific components
    if (m_leadingTitlesLabel) m_leadingTitlesLabel->hide();
    if (m_heroStack) m_heroStack->hide();
    if (m_trendingTitle) m_trendingTitle->hide();
    if (m_trendingScroll) m_trendingScroll->hide();
    if (m_gridTitleLabel) m_gridTitleLabel->setText("<span style='color: #ffffff;'>Installed</span> <span style='color: #bb86fc;'>Patches</span>");
    
    if (m_removeSelectedBtn) {
        m_removeSelectedBtn->show();
        m_removeSelectedBtn->setText("Remove Selected (0)");
        m_removeSelectedBtn->setEnabled(false);
    }
    if (m_clearLibraryBtn) {
        m_clearLibraryBtn->show();
    }

    QStringList pluginDirs = Config::getAllSteamPluginDirs();
    QSet<QString> installedAppIds;
    
    for (const QString& dirPath : pluginDirs) {
        QDir dir(dirPath);
        QStringList luaFiles = dir.entryList({"*.lua"}, QDir::Files);
        for (const QString& file : luaFiles) {
            QString appId = QFileInfo(file).baseName();
            if (!appId.isEmpty()) installedAppIds.insert(appId);
        }
    }

    if (installedAppIds.isEmpty()) {
        m_statusLabel->setText("No patches installed found.");
        m_stack->setCurrentIndex(1);
        return;
    }

    int count = 0;
    for (const QString& appId : installedAppIds) {
        if (count >= 100) break;

        QString name = m_nameCache.contains(appId) ? m_nameCache[appId] : "Loading...";
        bool hasFix = false;
        for (const auto& g : m_supportedGames) {
            if (g.id == appId) { hasFix = g.hasFix; break; }
        }

        if (name == "Loading...") m_pendingNameFetchIds.append(appId);

        GameCard* card = new GameCard(m_gridLayout->parentWidget());
        card->setGameData({{"name", name}, {"appid", appId}, {"supported", "local"}, {"hasFix", hasFix ? "true" : "false"}});
        card->setSelectable(true);
        connect(card, &GameCard::selectionChanged, this, &MainWindow::onSelectionChanged);
        m_gameCards.append(card);

        if (m_thumbnailCache.contains(appId)) card->setThumbnail(m_thumbnailCache[appId]);
        count++;
    }

    rearrangeGameGrid(true);
    QTimer::singleShot(50, this, &MainWindow::loadVisibleThumbnails);
    if (!m_pendingNameFetchIds.isEmpty()) startBatchNameFetch();
    
    m_statusLabel->setText(QString("Library: %1 patches found").arg(m_gameCards.count()));
    m_stack->setCurrentIndex(1);
    m_spinner->stop();
}

// ---- Sync ----
void MainWindow::startSync() {
    // Load persistent name cache from disk
    loadNameCache();

    // Try to load cached index for instant display
    if (loadCachedIndex()) {
        m_hasCachedData = true;
        m_statusLabel->setText("Syncing in background...");
    } else {
        // No cache available - show skeleton placeholders in grid
        m_hasCachedData = false;
        clearGameCards();
        for (int i = 0; i < 12; ++i) {
            GameCard* card = new GameCard(m_gridLayout->parentWidget());
            card->setSkeleton(true);
            m_gameCards.append(card);
        }
        rearrangeGameGrid(true);
        m_stack->setCurrentIndex(1);
        m_spinner->stop();
    }

    // Always start background sync to get fresh data
    m_syncWorker = new IndexDownloadWorker(this);
    connect(m_syncWorker, &IndexDownloadWorker::finished, this, &MainWindow::onSyncDone);
    connect(m_syncWorker, &IndexDownloadWorker::progress, [this](QString msg) {
        // Only show sync progress if we don't already have cached data displayed
        if (!m_hasCachedData) m_statusLabel->setText(msg);
    });
    connect(m_syncWorker, &IndexDownloadWorker::error, this, &MainWindow::onSyncError);
    m_syncWorker->start();
}

bool MainWindow::loadCachedIndex() {
    QString indexPath = Paths::getLocalIndexPath();
    if (!QFile::exists(indexPath)) return false;

    QFile file(indexPath);
    if (!file.open(QIODevice::ReadOnly)) return false;

    QByteArray data = file.readAll();
    file.close();

    QJsonDocument doc = QJsonDocument::fromJson(data);
    QJsonObject indexData = doc.object();
    QJsonArray arr = indexData["games"].toArray();
    if (arr.isEmpty()) return false;

    // Parse games and apply name cache
    QList<GameInfo> games;
    games.reserve(arr.size());
    for (const QJsonValue& val : arr) {
        QJsonObject obj = val.toObject();
        GameInfo game;
        game.id = obj["id"].toString();
        game.name = obj["name"].toString();
        // Apply cached name if the index has an unknown name
        if (game.name.startsWith("Unknown Game") && m_nameCache.contains(game.id)) {
            game.name = m_nameCache[game.id];
        }
        game.hasFix = obj["has_fix"].toBool(false);
        games.append(game);
    }

    m_supportedGames = games;
    m_searchInput->setFocus();

    // Display immediately
    if (m_currentMode == AppMode::LuaPatcher) {
        displayRandomGames();
    } else if (m_currentMode == AppMode::Library) {
        displayLibrary();
    }
    return true;
}

void MainWindow::onSyncDone(QList<GameInfo> games) {
    // Apply name cache to freshly downloaded data
    for (GameInfo& game : games) {
        if (game.name.startsWith("Unknown Game") && m_nameCache.contains(game.id)) {
            game.name = m_nameCache[game.id];
        }
    }
    m_supportedGames = games;
    m_spinner->stop();
    m_stack->setCurrentIndex(1);

    if (m_hasCachedData) {
        // Background refresh done - only re-display if user isn't searching
        m_hasCachedData = false;
        m_statusLabel->setText(QString("Ready ΓÇó %1 games").arg(m_supportedGames.size()));
        if (m_searchInput->text().trimmed().isEmpty()) {
            // Don't disrupt the user, just update data silently
        }
    } else {
        // First load (no cache was available)
        m_statusLabel->setText("Ready");
        m_searchInput->setFocus();
        if (!m_searchInput->text().isEmpty()) {
            doSearch();
        } else if (m_currentMode == AppMode::LuaPatcher) {
            displayRandomGames();
        } else if (m_currentMode == AppMode::Library) {
            displayLibrary();
        }
    }
}

void MainWindow::onSyncError(QString error) {
    m_spinner->stop();
    m_stack->setCurrentIndex(1);
    m_statusLabel->setText("Offline Mode");
    QMessageBox::warning(this, "Connection Error",
                         QString("Could not sync library:\n%1").arg(error));
}

// ---- Search ----
void MainWindow::onSearchChanged(const QString& text) {
    QString trimmed = text.trimmed();
    
    // UI feedback for home vs search
    if (trimmed.isEmpty()) {
        if (m_leadingTitlesLabel) m_leadingTitlesLabel->show();
        if (m_heroStack) m_heroStack->show();
        if (m_trendingTitle) m_trendingTitle->show();
        if (m_trendingScroll) m_trendingScroll->show();
        
        clearGameCards();
        if (m_currentMode == AppMode::LuaPatcher) {
            displayRandomGames();
        } else if (m_currentMode == AppMode::Library) {
            displayLibrary();
        }
    } else {
        if (m_leadingTitlesLabel) m_leadingTitlesLabel->hide();
        if (m_heroStack) m_heroStack->hide();
        if (m_trendingTitle) m_trendingTitle->hide();
        if (m_trendingScroll) m_trendingScroll->hide();
        m_debounceTimer->stop();
        m_debounceTimer->start(400);
    }
}

void MainWindow::doSearch() {
    QString query = m_searchInput->text().trimmed();
    if (query.isEmpty()) return;
    if (!m_networkManager) return;
    
    cancelNameFetches();
    m_currentSearchId++;
    m_statusLabel->setText("Searching...");
    
    QJsonArray localResults;
    int count = 0;
    for (const auto& game : m_supportedGames) {
        if (count >= 100) break;
        if (m_currentMode == AppMode::Library) {
        }
        
        if (game.name.contains(query, Qt::CaseInsensitive) || game.id == query) {
            QJsonObject item;
            item["id"] = game.id;
            item["name"] = game.name;
            item["supported_local"] = true;
            localResults.append(item);
            count++;
        }
    }
    displayResults(localResults);
    
    m_spinner->start();
    if (m_gameCards.isEmpty()) m_stack->setCurrentIndex(0);
    
    bool isNumeric;
    query.toInt(&isNumeric);
    
    if (isNumeric) {
        QUrl urlStore(QString("https://store.steampowered.com/api/appdetails?appids=%1").arg(query));
        QNetworkRequest reqStore(urlStore);
        QNetworkReply* repStore = m_networkManager->get(reqStore);
        repStore->setProperty("sid", m_currentSearchId);
        repStore->setProperty("type", "steam_details");
        repStore->setProperty("query_id", query);
    } else {
        if (m_activeReply) m_activeReply->abort();
        QUrl url("https://store.steampowered.com/api/storesearch");
        QUrlQuery urlQuery;
        urlQuery.addQueryItem("term", query);
        urlQuery.addQueryItem("l", "english");
        urlQuery.addQueryItem("cc", "US");
        url.setQuery(urlQuery);
        QNetworkRequest request(url);
        m_activeReply = m_networkManager->get(request);
        m_activeReply->setProperty("sid", m_currentSearchId);
        m_activeReply->setProperty("type", "store_search");
    }
}

void MainWindow::onSearchFinished(QNetworkReply* reply) {
    reply->deleteLater();
    if (reply == m_activeReply) m_activeReply = nullptr;
    if (reply->error() == QNetworkReply::OperationCanceledError) return;
    
    QString type = reply->property("type").toString();
    if (type.isEmpty()) return;
    
    int sid = reply->property("sid").toInt();
    if (sid != m_currentSearchId) return;
    
    if (reply->error() != QNetworkReply::NoError) {
        if (m_gameCards.isEmpty() && type == "store_search")
            m_statusLabel->setText("Search failed");
        return;
    }
    QByteArray data = reply->readAll();
    QJsonDocument doc = QJsonDocument::fromJson(data);
    QJsonObject obj = doc.object();
    
    QList<QJsonObject> newItems;
    
    if (type == "store_search") {
        QJsonArray remoteItems = obj["items"].toArray();
        for (const QJsonValue& val : remoteItems)
            newItems.append(val.toObject());
    }
    else if (type == "steam_details") {
        QString qId = reply->property("query_id").toString();
        bool ok = false;
        if (obj.contains(qId)) {
            QJsonObject root = obj[qId].toObject();
            if (root["success"].toBool() && root.contains("data")) {
                QJsonObject d = root["data"].toObject();
                QJsonObject item;
                item["id"] = d["steam_appid"].toInt();
                item["name"] = d["name"].toString();
                newItems.append(item);
                ok = true;
            }
        }
        if (!ok) {
            QUrl urlSpy(QString("https://steamspy.com/api.php?request=appdetails&appid=%1").arg(qId));
            QNetworkReply* repSpy = m_networkManager->get(QNetworkRequest(urlSpy));
            repSpy->setProperty("sid", sid);
            repSpy->setProperty("type", "steamspy_details");
            return;
        }
    }
    else if (type == "steamspy_details") {
        if (obj.contains("name") && !obj["name"].toString().isEmpty()) {
            QJsonObject item;
            item["id"] = obj["appid"].isDouble() ? obj["appid"].toInt() : obj["appid"].toString().toInt();
            item["name"] = obj["name"].toString();
            newItems.append(item);
        }
    }
    
    m_spinner->stop();
    m_stack->setCurrentIndex(1);
    
    QMap<QString, GameCard*> cardMap;
    for (GameCard* c : m_gameCards) cardMap.insert(c->appId(), c);
    
    bool changed = false;
    
    for (const auto& item : newItems) {
        QString id = QString::number(item["id"].toInt());
        QString name = item["name"].toString("Unknown");
        
        bool supported = false;
        bool hasFix = false;
        for (const auto& g : m_supportedGames) {
            if (g.id == id) { supported = true; hasFix = g.hasFix; break; }
        }
        
        if (cardMap.contains(id)) {
            GameCard* existing = cardMap[id];
            QMap<QString, QString> ed = existing->gameData();
            if (ed["name"].contains("Unknown", Qt::CaseInsensitive) || ed["name"] == id) {
                ed["name"] = name;
                ed["supported"] = supported ? "true" : "false";
                ed["hasFix"] = hasFix ? "true" : "false";
                existing->setGameData(ed);
                changed = true;
            }
        } else {
            QMap<QString, QString> cd;
            cd["name"] = name;
            cd["appid"] = id;
            cd["supported"] = supported ? "true" : "false";
            cd["hasFix"] = hasFix ? "true" : "false";
            
            GameCard* card = new GameCard(m_gridLayout->parentWidget());
            card->setGameData(cd);
            connect(card, &GameCard::clicked, this, &MainWindow::onCardClicked);
            
            int idx = m_gameCards.count();
            m_gameCards.append(card);
            cardMap.insert(id, card);
            changed = true;
            
            if (m_thumbnailCache.contains(id)) {
                card->setThumbnail(m_thumbnailCache[id]);
            } else if (!m_activeThumbnailDownloads.contains(id) && !m_pendingThumbnailIds.contains(id)) {
                m_pendingThumbnailIds.append(id);
            }
        }
    }
    
    if (changed) {
        rearrangeGameGrid(true);
    }
    
    // Start draining the throttled thumbnail queue
    QTimer::singleShot(50, this, &MainWindow::loadVisibleThumbnails);
    
    m_statusLabel->setText(m_gameCards.isEmpty()
        ? "No results found"
        : QString("Found %1 results").arg(m_gameCards.count()));
}

// ---- Display results as grid cards ----
void MainWindow::displayResults(const QJsonArray& items) {
    clearGameCards();
    m_selectedGame.clear();
    cancelNameFetches();
    m_pendingNameFetchIds.clear();

    if (items.isEmpty()) {
        m_statusLabel->setText("No results found.");
        return;
    }

    // Hide Home components
    if (m_leadingTitlesLabel) m_leadingTitlesLabel->hide();
    if (m_heroStack) m_heroStack->hide();
    if (m_trendingTitle) m_trendingTitle->hide();
    if (m_trendingScroll) m_trendingScroll->hide();
    if (m_gridTitleLabel) m_gridTitleLabel->setText(QString("Results (%1)").arg(items.size()));

    int idx = 0;
    for (const QJsonValue& val : items) {
        if (idx >= 120) break;
        QJsonObject item = val.toObject();
        QString name = item["name"].toString("Unknown");
        QString appid = item.contains("id")
            ? (item["id"].isString() ? item["id"].toString() : QString::number(item["id"].toInt()))
            : "0";
        
        bool supported = false;
        bool hasFix = false;
        for (const auto& g : m_supportedGames) {
            if (g.id == appid) { supported = true; hasFix = g.hasFix; break; }
        }
        
        GameCard* card = new GameCard(m_gridLayout->parentWidget());
        card->setGameData({{"name", name}, {"appid", appid}, {"supported", supported ? "true" : "false"}, {"hasFix", hasFix ? "true" : "false"}});
        connect(card, &GameCard::clicked, this, &MainWindow::onCardClicked);
        m_gameCards.append(card);
        
        if (m_thumbnailCache.contains(appid)) card->setThumbnail(m_thumbnailCache[appid]);
        if (name.startsWith("Unknown Game") || name == "Unknown") m_pendingNameFetchIds.append(appid);
        idx++;
    }
    
    rearrangeGameGrid(true);
    
    m_statusLabel->setText(QString("Search: Found %1 matches").arg(items.size()));
    QTimer::singleShot(50, this, &MainWindow::loadVisibleThumbnails);
    if (!m_pendingNameFetchIds.isEmpty()) startBatchNameFetch();
}

// ---- Card clicked ----
void MainWindow::onCardClicked(GameCard* card) {
    if (m_selectedCard) m_selectedCard->setSelected(false);
    
    if (!card) {
        m_selectedCard = nullptr;
        m_selectedGame.clear();
        m_targetGlowColor = Colors::toQColor(Colors::PRIMARY);
        m_glowTimer->start(16);
        return;
    }
    
    m_selectedCard = card;
    card->setSelected(true);
    
    QMap<QString, QString> data = card->gameData();
    m_selectedGame = data;
    bool isSupported = (data["supported"] == "true");
    bool hasFix = (data["hasFix"] == "true");
    
    // Switch to details page and load data
    m_gameDetailsPage->loadGame(data["appid"], data["name"], isSupported, hasFix);
    m_stack->setCurrentIndex(3); // Game details page
    
    m_targetGlowColor = card->getDominantColor().isValid() ? card->getDominantColor() : Colors::toQColor(Colors::PRIMARY);
    m_glowTimer->start(16);
}

void MainWindow::onGameDetailsBack() {
    // Return to the main grid view
    m_stack->setCurrentIndex(1);
    m_gameDetailsPage->clear();

    
    if (m_selectedCard) m_selectedCard->setSelected(false);
    m_selectedCard = nullptr;
    m_selectedGame.clear();
    
    m_targetGlowColor = Colors::toQColor(Colors::PRIMARY);
    m_glowTimer->start(16);
}

void MainWindow::onInstallFromDetails(const QString& appId, const QString& name, bool hasFix) {
    // This runs the same logic as the old Add to Library button
    runPatchLogic();
}

// ---- Patch / Generate / Restart / Fix / Remove ----
void MainWindow::doAddGame() {
    if (m_selectedGame.isEmpty()) return;
    bool hasFix = (m_selectedGame["hasFix"] == "true");
    
    // Favor generation if remote system is removed/unavailable
    if (hasFix) {
        runPatchLogic(); 
    } else {
        runGenerateLogic();
    }
}

void MainWindow::doRemoveGame() {
    if (m_selectedGame.isEmpty()) return;
    QString appId = m_selectedGame["appid"];
    QString name = m_selectedGame["name"];
    
    if (QMessageBox::question(this, "Remove Patch", 
        QString("Are you sure you want to remove the patch for %1?\nThis will delete the lua file from your Steam plugin folder.").arg(name),
        QMessageBox::Yes | QMessageBox::No) != QMessageBox::Yes) return;
        
    QStringList pluginDirs = Config::getAllSteamPluginDirs();
    bool deleted = false;
    
    for (const QString& dirPath : pluginDirs) {
        QDir dir(dirPath);
        QString filePath = dir.filePath(appId + ".lua");
        if (QFile::exists(filePath)) {
            if (QFile::remove(filePath)) deleted = true;
        }
    }
    
    if (deleted) {
        m_statusLabel->setText(QString("Removed patch for %1").arg(name));
        displayLibrary();
    } else {
        QMessageBox::warning(this, "Error", "Failed to remove patch file. It may not exist or is in use.");
    }
}

void MainWindow::runPatchLogic() {
    if (m_selectedGame.isEmpty()) return;
    m_progress->setValue(0);
    m_terminalDialog->hide(); // Ensure terminal dialog stays hidden
    
    m_dlWorker = new LuaDownloadWorker(m_selectedGame["appid"], this);
    connect(m_dlWorker, &LuaDownloadWorker::finished, this, &MainWindow::onPatchDone);
    connect(m_dlWorker, &LuaDownloadWorker::progress, [this](qint64 dl, qint64 total) {
        if (total > 0) {
            int pct = static_cast<int>(dl * 100 / total);
            m_progress->setValue(pct);
            if (m_stack->currentIndex() == 3) { // GameDetailsPage index
                m_gameDetailsPage->updateInstallProgress(pct);
            }
        }
    });
    connect(m_dlWorker, &LuaDownloadWorker::status, [this](QString msg) { m_statusLabel->setText(msg); });
    connect(m_dlWorker, &LuaDownloadWorker::error, this, &MainWindow::onPatchError);
    m_dlWorker->start();
}

void MainWindow::onPatchDone(QString path) {
    try {
        QStringList targetDirs = Config::getAllSteamPluginDirs();
        if (targetDirs.isEmpty()) {
            targetDirs.append(Config::getSteamPluginDir());
        }
        bool ok = false;
        QString lastErr;
        for (const QString& pluginDir : targetDirs) {
            QDir dir(pluginDir);
            if (!dir.exists()) {
                if (!dir.mkpath(pluginDir)) {
                    continue;
                }
            }
            QString dest = dir.filePath(m_selectedGame["appid"] + ".lua");
            if (QFile::exists(dest)) { QFile::remove(dest); }
            if (QFile::copy(path, dest)) { ok = true; }
            else { lastErr = "Failed to copy patch file to " + pluginDir; }
        }
        if (!ok) throw std::runtime_error(lastErr.toStdString());
        QFile::remove(path);
        
        // Increment games patched
        if (!m_isGuest && !m_username.isEmpty()) {
            int currentPatched = m_userData["games_patched"].toInt(0);
            currentPatched++;
            m_userData["games_patched"] = currentPatched;
            
            QJsonObject payload;
            payload["games_patched"] = currentPatched;
            
            QUrl url(Config::WEBSERVER_BASE_URL + "/api/user/profile?username=" + m_username);
            QNetworkRequest req(url);
            req.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
            m_networkManager->post(req, QJsonDocument(payload).toJson());
        }
        
        m_progress->hide();
        m_statusLabel->setText("Patch Installed!");
        
        if (m_stack->currentIndex() == 3) {
            m_gameDetailsPage->installFinished();
        }
    } catch (const std::exception& e) {
        onPatchError(QString::fromStdString(e.what()));
    }
}

void MainWindow::onPatchError(QString error) {
    m_progress->hide();
    m_statusLabel->setText("Error: " + error);
    
    if (m_stack->currentIndex() == 3) {
        m_gameDetailsPage->installError(error);
    }
}

void MainWindow::runGenerateLogic() {
    if (m_selectedGame.isEmpty()) return;
    m_progress->setValue(0);
    m_terminalDialog->clear();
    m_terminalDialog->appendLog(QString("Initializing generation for: %1 (%2)").arg(m_selectedGame["name"]).arg(m_selectedGame["appid"]), "INFO");
    m_terminalDialog->show();
    
    m_genWorker = new GeneratorWorker(m_selectedGame["appid"], this);
    connect(m_genWorker, &GeneratorWorker::finished, this, [this](QString) {
        m_progress->hide();
        m_statusLabel->setText("Patch Generated & Installed!");
        m_terminalDialog->setFinished(true);
        
        if (m_stack->currentIndex() == 3) {
            m_gameDetailsPage->installFinished();
        }
        
        QString appId = m_selectedGame["appid"];
        for (GameCard* card : m_gameCards) {
            if (card->appId() == appId) {
                QMap<QString, QString> d = card->gameData();
                d["supported"] = "true";
                card->setGameData(d);
                break;
            }
        }
    });
    connect(m_genWorker, &GeneratorWorker::progress, [this](qint64 dl, qint64 total) {
        if (total > 0) {
            int pct = static_cast<int>(dl * 100 / total);
            m_progress->setValue(pct);
            if (m_stack->currentIndex() == 3) {
                m_gameDetailsPage->updateInstallProgress(pct);
            }
        }
    });
    connect(m_genWorker, &GeneratorWorker::status, [this](QString msg) { m_statusLabel->setText(msg); });
    connect(m_genWorker, &GeneratorWorker::log, m_terminalDialog, &TerminalDialog::appendLog);
    connect(m_genWorker, &GeneratorWorker::error, this, &MainWindow::onPatchError);
    m_genWorker->start();
}

void MainWindow::doRestart() {
    m_restartWorker = new RestartWorker(this);
    connect(m_restartWorker, &RestartWorker::finished, m_statusLabel, &QLabel::setText);
    m_restartWorker->start();
}

// ---- Mode switching ----
void MainWindow::cancelNameFetches() {
    m_fetchingNames = false;
    for (QNetworkReply* r : m_activeNameFetches) { if (r) { r->abort(); r->deleteLater(); } }
    m_activeNameFetches.clear();
    m_pendingNameFetchIds.clear();
}

void MainWindow::switchMode(AppMode mode) {
    if (m_currentMode == mode) return;
    m_currentMode = mode;
    updateModeUI();
    
    onCardClicked(nullptr);
    clearGameCards();
    
    if (m_currentMode == AppMode::LuaPatcher) {
        if (m_searchInput->text().trimmed().isEmpty()) {
            displayRandomGames();
        } else {
            doSearch();
        }
    } else if (m_currentMode == AppMode::Library) {
        displayLibrary();
    }
}

void MainWindow::updateModeUI() {
    m_tabLua->setAccentColor(m_currentMode == AppMode::LuaPatcher ? Colors::PRIMARY : "transparent");
    m_tabLibrary->setAccentColor(m_currentMode == AppMode::Library ? Colors::ACCENT_GREEN : "transparent");
    m_tabSettings->setAccentColor(m_currentMode == AppMode::Settings ? Colors::PRIMARY : "transparent");

    // Animate sidebar indicator to the active tab
    GlassButton* activeTab = nullptr;
    if (m_currentMode == AppMode::LuaPatcher) activeTab = m_tabLua;
    else if (m_currentMode == AppMode::Library) activeTab = m_tabLibrary;
    else if (m_currentMode == AppMode::Settings) activeTab = m_tabSettings;
    
    if (activeTab && m_sidebarIndicator) {
        // Map the tab's center-left position to the sidebar widget's coordinate space
        QPoint tabPos = activeTab->mapTo(m_sidebarWidget, QPoint(0, 0));
        int indicatorY = tabPos.y() + (activeTab->height() - m_sidebarIndicator->height()) / 2;
        QPoint targetPos(6, indicatorY);
        
        if (m_sidebarIndicator->pos().isNull() || !m_sidebarIndicator->isVisible()) {
            // First time ΓÇö snap directly without animation
            m_sidebarIndicator->move(targetPos);
            m_sidebarIndicator->show();
        } else {
            // Animate slide
            m_indicatorAnimation->stop();
            m_indicatorAnimation->setStartValue(m_sidebarIndicator->pos());
            m_indicatorAnimation->setEndValue(targetPos);
            m_indicatorAnimation->start();
        }
    }
    
    if (m_currentMode == AppMode::LuaPatcher) {
    } else if (m_currentMode == AppMode::Library) {
    }
    
    if (m_currentMode == AppMode::Settings) {
        m_stack->setCurrentIndex(2);
    } else {
        m_stack->setCurrentIndex(1);
    }
}

// ---- Batch name fetch ----
void MainWindow::startBatchNameFetch() {
    if (m_pendingNameFetchIds.isEmpty()) { m_fetchingNames = false; m_spinner->stop(); return; }
    m_fetchingNames = true;
    m_nameFetchSearchId = m_currentSearchId;
    m_spinner->start();
    m_statusLabel->setText(QString("Found %1 results %2 Fetching game names...").arg(m_gameCards.count()).arg(QChar(0x2022)));
    // Fetch all displayed cards concurrently for faster loading
    for (int i = 0; i < 12 && !m_pendingNameFetchIds.isEmpty(); ++i) processNextNameFetch();
}

void MainWindow::processNextNameFetch() {
    if (m_pendingNameFetchIds.isEmpty() || !m_fetchingNames) {
        if (m_activeNameFetches.isEmpty() && m_fetchingNames) {
            m_fetchingNames = false; m_spinner->stop();
            m_statusLabel->setText(QString("Found %1 results").arg(m_gameCards.count()));
        }
        return;
    }
    QString appId = m_pendingNameFetchIds.takeFirst();
    QUrl url(QString("https://store.steampowered.com/api/appdetails?appids=%1").arg(appId));
    QNetworkRequest request(url);
    request.setHeader(QNetworkRequest::UserAgentHeader, "SteamLuaPatcher/2.0");
    QNetworkReply* reply = m_networkManager->get(request);
    reply->setProperty("fetch_appid", appId);
    reply->setProperty("fetch_type", "steam_store");
    reply->setProperty("fetch_sid", m_nameFetchSearchId);
    m_activeNameFetches.append(reply);
    connect(reply, &QNetworkReply::finished, this, [this, reply]() { onGameNameFetched(reply); });
}

void MainWindow::onGameNameFetched(QNetworkReply* reply) {
    reply->deleteLater();
    m_activeNameFetches.removeOne(reply);
    int fetchSid = reply->property("fetch_sid").toInt();
    if (fetchSid != m_nameFetchSearchId || !m_fetchingNames) { processNextNameFetch(); return; }
    
    QString appId = reply->property("fetch_appid").toString();
    QString fetchType = reply->property("fetch_type").toString();
    QString gameName;
    
    if (reply->error() == QNetworkReply::NoError) {
        QJsonObject obj = QJsonDocument::fromJson(reply->readAll()).object();
        if (fetchType == "steam_store") {
            if (obj.contains(appId)) {
                QJsonObject root = obj[appId].toObject();
                if (root["success"].toBool() && root.contains("data"))
                    gameName = root["data"].toObject()["name"].toString();
            }
        } else if (fetchType == "steamspy") {
            if (obj.contains("name") && !obj["name"].toString().isEmpty())
                gameName = obj["name"].toString();
        }
    }
    
    if (gameName.isEmpty() && fetchType == "steam_store") {
        QUrl spyUrl(QString("https://steamspy.com/api.php?request=appdetails&appid=%1").arg(appId));
        QNetworkRequest req(spyUrl);
        req.setHeader(QNetworkRequest::UserAgentHeader, "SteamLuaPatcher/2.0");
        QNetworkReply* spyReply = m_networkManager->get(req);
        spyReply->setProperty("fetch_appid", appId);
        spyReply->setProperty("fetch_type", "steamspy");
        spyReply->setProperty("fetch_sid", m_nameFetchSearchId);
        m_activeNameFetches.append(spyReply);
        connect(spyReply, &QNetworkReply::finished, this, [this, spyReply]() { onGameNameFetched(spyReply); });
        return;
    }
    
    if (!gameName.isEmpty()) {
        // Persist to name cache so we never fetch this again
        m_nameCache[appId] = gameName;
        saveNameCache();

        for (GameCard* card : m_gameCards) {
            if (card->appId() == appId) {
                QMap<QString, QString> d = card->gameData();
                d["name"] = gameName;
                card->setGameData(d);
                break;
            }
        }
    }
    processNextNameFetch();
}

// ---- Thumbnail lazy loading ----
void MainWindow::loadVisibleThumbnails() {
    if (!m_mainScrollArea || !m_networkManager) return;
    QRect visibleRect = m_mainScrollArea->viewport()->rect();
    
    // Collect IDs of visible cards that need thumbnails
    for (GameCard* card : m_gameCards) {
        // Map card position correctly to scroll viewport
        QPoint pos = card->mapTo(m_mainScrollArea->viewport(), QPoint(0,0));
        QRect cardInView(pos, card->size());
        
        // Add some buffer for smoother loading
        if (!visibleRect.adjusted(-200, -200, 200, 200).intersects(cardInView)) continue;
        
        QString appId = card->appId();
        if (appId.isEmpty() || card->hasThumbnail()) continue;
        if (m_thumbnailCache.contains(appId)) { card->setThumbnail(m_thumbnailCache[appId]); continue; }
        if (m_activeThumbnailDownloads.contains(appId)) continue;
        if (m_pendingThumbnailIds.contains(appId)) continue;
        
        m_pendingThumbnailIds.append(appId);
    }
    
    // Drain pending queue up to the concurrency limit
    while (m_activeThumbnailCount < MAX_CONCURRENT_THUMBNAILS && !m_pendingThumbnailIds.isEmpty()) {
        QString appId = m_pendingThumbnailIds.takeFirst();
        if (m_activeThumbnailDownloads.contains(appId)) continue;
        
        m_activeThumbnailDownloads.insert(appId);
        m_activeThumbnailCount++;
        
        // Use the non-2x version (600x900) which is ~50% smaller in filesize
        QString thumbUrl = QString("https://cdn.akamai.steamstatic.com/steam/apps/%1/library_600x900.jpg").arg(appId);
        QNetworkRequest req{QUrl(thumbUrl)};
        req.setAttribute(QNetworkRequest::Attribute(QNetworkRequest::User + 1), appId);
        req.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
        
        QNetworkReply* tr = m_networkManager->get(req);
        tr->setProperty("appid", appId);
        connect(tr, &QNetworkReply::finished, this, [this, tr]() { onThumbnailDownloaded(tr); });
    }
}

void MainWindow::onThumbnailDownloaded(QNetworkReply* reply) {
    reply->deleteLater();
    QString appId = reply->property("appid").toString();
    m_activeThumbnailDownloads.remove(appId);
    m_activeThumbnailCount = qMax(0, m_activeThumbnailCount - 1);
    
    if (appId.isEmpty()) {
        // Drain the next request from the pending queue
        loadVisibleThumbnails();
        return;
    }
    
    QPixmap pixmap;
    bool success = (reply->error() == QNetworkReply::NoError) && pixmap.loadFromData(reply->readAll());
    
    // Fallback logic for older games that don't have the new vertical Steam library asset
    if (!success) {
        QString originalUrl = reply->url().toString();
        if (originalUrl.contains("library_600x900")) {
            m_activeThumbnailDownloads.insert(appId);
            m_activeThumbnailCount++;
            QString fallbackUrl = QString("https://cdn.akamai.steamstatic.com/steam/apps/%1/header.jpg").arg(appId);
            QNetworkRequest req{QUrl(fallbackUrl)};
            req.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
            QNetworkReply* tr = m_networkManager->get(req);
            tr->setProperty("appid", appId);
            connect(tr, &QNetworkReply::finished, this, [this, tr]() { onThumbnailDownloaded(tr); });
            return;
        }
        
        // If even fallback fails, aggressively cache failure as a null pixmap
        // to prevent spamming the steam servers on every frame scroll
        m_thumbnailCache[appId] = QPixmap();
        // Drain the next request from the pending queue
        loadVisibleThumbnails();
        return;
    }
    
    // Save successful fetch to cache and aggressively update matching UI cards
    m_thumbnailCache[appId] = pixmap;
    for (GameCard* card : m_gameCards) {
        if (card->appId() == appId) {
            card->setThumbnail(pixmap);
            // Don't break, multiple modes might show the same appID (e.g. search + library)
        }
    }
    
    // Drain the next request from the pending queue
    loadVisibleThumbnails();
}

// ---- Persistent name cache ----
void MainWindow::loadNameCache() {
    QString path = QDir(Paths::getLocalCacheDir()).filePath("name_cache.json");
    QFile file(path);
    if (!file.open(QIODevice::ReadOnly)) return;
    QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
    file.close();
    QJsonObject obj = doc.object();
    for (auto it = obj.begin(); it != obj.end(); ++it) {
        m_nameCache[it.key()] = it.value().toString();
    }
}

void MainWindow::saveNameCache() {
    QString path = QDir(Paths::getLocalCacheDir()).filePath("name_cache.json");
    QJsonObject obj;
    for (auto it = m_nameCache.begin(); it != m_nameCache.end(); ++it) {
        obj[it.key()] = it.value();
    }
    QFile file(path);
    if (file.open(QIODevice::WriteOnly)) {
        file.write(QJsonDocument(obj).toJson(QJsonDocument::Compact));
        file.close();
    }
}

// ---- Library Management Logic ----
void MainWindow::onSelectionChanged(bool selected, GameCard* card) {
    Q_UNUSED(selected);
    Q_UNUSED(card);
    int selectedCount = 0;
    for (GameCard* c : m_gameCards) {
        if (c->isSelected()) selectedCount++;
    }
    if (m_removeSelectedBtn) {
        m_removeSelectedBtn->setText(QString("Remove Selected (%1)").arg(selectedCount));
        m_removeSelectedBtn->setEnabled(selectedCount > 0);
    }
}

void MainWindow::onRemoveSelectedClicked() {
    QStringList toRemove;
    for (GameCard* c : m_gameCards) {
        if (c->isSelected()) toRemove.append(c->appId());
    }
    if (toRemove.isEmpty()) return;

    QStringList pluginDirs = Config::getAllSteamPluginDirs();
    for (const QString& appId : toRemove) {
        for (const QString& dirPath : pluginDirs) {
            QFile file(dirPath + "/" + appId + ".lua");
            if (file.exists()) file.remove();
        }
    }
    displayLibrary(); // Refresh grid live
}

void MainWindow::onClearLibraryClicked() {
    QMessageBox::StandardButton reply = QMessageBox::warning(this, "Clear Library", 
        "Are you absolutely sure you want to permanently delete ALL installed patches from Steam?",
        QMessageBox::Yes | QMessageBox::No);
    
    if (reply == QMessageBox::Yes) {
        QStringList pluginDirs = Config::getAllSteamPluginDirs();
        for (const QString& dirPath : pluginDirs) {
            QDir dir(dirPath);
            QStringList luaFiles = dir.entryList({"*.lua"}, QDir::Files);
            for (const QString& f : luaFiles) {
                QFile::remove(dir.absoluteFilePath(f));
            }
        }
        displayLibrary(); // Refresh grid live
    }
}

void MainWindow::setInitialUser(const QString& username, const QJsonObject& data, bool guest) {
    m_username = username;
    m_userData = data;
    m_isGuest = guest;
    
    if (m_topUsernameLabel) m_topUsernameLabel->setText(m_username);
    
    if (!m_isGuest && !m_username.isEmpty()) {
        refreshFriendsList();
        
        // Start Heartbeat Timer (every 2 minutes)
        if (!m_heartbeatTimer) {
            m_heartbeatTimer = new QTimer(this);
            connect(m_heartbeatTimer, &QTimer::timeout, this, &MainWindow::sendHeartbeat);
            m_heartbeatTimer->start(120000); // 120 seconds
            sendHeartbeat(); // Send first heartbeat immediately
        }
        
        // Start Notification Polling Timer (every 30 seconds)
        if (!m_notifTimer) {
            m_notifTimer = new QTimer(this);
            connect(m_notifTimer, &QTimer::timeout, this, [this]() {
                fetchNotificationCount();
                refreshFriendsList();
            });
            m_notifTimer->start(30000); // 30 seconds
            fetchNotificationCount(); // Fetch immediately
        }
        
        // Start Background Chat Poller for unread messages (every 5 seconds)
        if (!m_chatPollerTimer) {
            m_chatPollerTimer = new QTimer(this);
            connect(m_chatPollerTimer, &QTimer::timeout, this, &MainWindow::pollChatHistories);
            m_chatPollerTimer->start(5000); // 5 seconds
        }
    }
    updateSidebarAvatar();
}

void MainWindow::sendHeartbeat() {
    if (m_isGuest || m_username.isEmpty()) return;
    
    // Send heartbeat to server to update last_seen
    QUrl url(Config::WEBSERVER_BASE_URL + "/api/user/heartbeat?username=" + m_username);
    QNetworkRequest request(url);
    m_networkManager->post(request, QByteArray());
}
void MainWindow::pollChatHistories() {
    if (m_isGuest || m_username.isEmpty()) return;
    
    for (const QString& friendName : m_friendUsernames) {
        QUrl url(Config::WEBSERVER_BASE_URL + "/api/social/chat/history");
        QUrlQuery query;
        query.addQueryItem("user1", m_username);
        query.addQueryItem("user2", friendName);
        url.setQuery(query);
        
        QNetworkRequest req(url);
        QNetworkReply* reply = m_networkManager->get(req);
        
        connect(reply, &QNetworkReply::finished, this, [this, reply, friendName]() {
            reply->deleteLater();
            if (reply->error() != QNetworkReply::NoError) return;
            
            QJsonDocument doc = QJsonDocument::fromJson(reply->readAll());
            if (!doc.isArray()) return;
            
            int msgCount = doc.array().size();
            
            QSettings settings("leVi Studios", "LuaPatcher");
            int savedMsgCount = settings.value("Social/MsgCount_" + friendName, 0).toInt();
            
            if (msgCount > savedMsgCount) {
                settings.setValue("Social/MsgCount_" + friendName, msgCount);
                // Trigger a UI refresh because unread count increased!
                QTimer::singleShot(0, this, &MainWindow::refreshFriendsList);
            }
        });
    }
}

void MainWindow::refreshFriendsList() {
    if (m_isGuest || m_username.isEmpty()) return;
    
    QUrl url(Config::WEBSERVER_BASE_URL + "/api/social/friends");
    QUrlQuery query;
    query.addQueryItem("username", m_username);
    url.setQuery(query);
    
    QNetworkRequest request(url);
    QNetworkReply* reply = m_networkManager->get(request);
    
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        if (reply->error() != QNetworkReply::NoError) return;
        
        QJsonDocument doc = QJsonDocument::fromJson(reply->readAll());
        QJsonArray friendsArray = doc.array();
        
        // Clear current list
        QLayoutItem* item;
        while ((item = m_friendsLayout->takeAt(0)) != nullptr) {
            if (item->widget()) item->widget()->deleteLater();
            delete item;
        }
        
        if (friendsArray.isEmpty()) {
            QLabel* noFriends = new QLabel("No friends yet. Add some!");
            noFriends->setStyleSheet("color: rgba(255, 255, 255, 0.4); font-size: 12px; font-style: italic; margin: 20px;");
            noFriends->setAlignment(Qt::AlignCenter);
            m_friendsLayout->addWidget(noFriends);
            return;
        }
        
        QList<QJsonObject> friendsList;
        int onlineCount = 0;
        m_friendUsernames.clear();
        for (const QJsonValue& v : friendsArray) {
            QJsonObject f = v.toObject();
            friendsList.append(f);
            m_friendUsernames.append(f["username"].toString());
            if (f["online"].toBool()) onlineCount++;
        }
        
        // Sort: Online first, then alphabetical
        std::sort(friendsList.begin(), friendsList.end(), [](const QJsonObject& a, const QJsonObject& b) {
            bool aOnline = a["online"].toBool();
            bool bOnline = b["online"].toBool();
            if (aOnline != bOnline) return aOnline > bOnline;
            return a["username"].toString().compare(b["username"].toString(), Qt::CaseInsensitive) < 0;
        });
        
        // Update header count
        QLabel* header = m_rightPanelWidget->findChild<QLabel*>("friendsHeader");
        if (header) header->setText(QString("FRIENDS (%1 ONLINE)").arg(onlineCount));
        
        // Store friends count for profile card
        m_userData["friends_count"] = friendsList.size();
        
        for (const QJsonObject& f : friendsList) {
            QPushButton* friendBtn = new QPushButton();
            friendBtn->setFixedHeight(60);
            friendBtn->setCursor(Qt::PointingHandCursor);
            friendBtn->setStyleSheet(
                "QPushButton {"
                "  background: transparent;"
                "  border: none;"
                "  border-radius: 12px;"
                "  text-align: left;"
                "}"
                "QPushButton:hover {"
                "  background: rgba(255, 255, 255, 0.05);"
                "}"
            );
            
            QString fName = f["username"].toString();
            QString fAvatarUrl = f["avatar_url"].toString();
            connect(friendBtn, &QPushButton::clicked, this, [this, friendBtn, fName, fAvatarUrl]() {
                if (m_friendPopover) {
                    m_friendPopover->deleteLater();
                }
                m_friendPopover = new FriendPopover(fName, fAvatarUrl, this);
                
                // Connect signals
                connect(m_friendPopover, &FriendPopover::messageClicked, this, [this, fAvatarUrl](const QString& fName) {
                    openChat(fName, fAvatarUrl);
                });
                connect(m_friendPopover, &FriendPopover::viewProfileClicked, this, [this](const QString& username) {
                    UserProfileDialog* dlg = new UserProfileDialog(username, m_username, m_networkManager, this);
                    
                    // Show a blur overlay behind the dialog
                    showBlurOverlay();
                    
                    // Center the dialog manually to be safe
                    dlg->move(geometry().center() - dlg->rect().center());
                    dlg->exec();
                    
                    hideBlurOverlay();
                    dlg->deleteLater();
                });
                connect(m_friendPopover, &FriendPopover::removeFriendClicked, this, &MainWindow::removeFriend);
                
                // Map the left-center of the friendBtn to global coordinates
                // We map to parent of 'this' just in case, but mapToGlobal handles screen coords
                // Since FriendPopover is a popup, it needs screen coords
                QPoint globalPos = friendBtn->mapToGlobal(QPoint(0, friendBtn->height() / 2));
                
                m_friendPopover->popup(globalPos);
            });

            QHBoxLayout* lay = new QHBoxLayout(friendBtn);
            lay->setContentsMargins(10, 5, 10, 5);
            lay->setSpacing(12);
            
            // Avatar
            QLabel* av = new QLabel();
            av->setFixedSize(44, 44);
            QPixmap pix(44, 44);
            pix.fill(Qt::transparent);
            QPainter p(&pix);
            p.setRenderHint(QPainter::Antialiasing);
            
            QString avUrl = f["avatar_url"].toString();
            if (!avUrl.isEmpty()) {
                QPixmap original;
                original.loadFromData(QByteArray::fromBase64(avUrl.toUtf8()));
                if (!original.isNull()) {
                    QPainterPath path;
                    path.addEllipse(0, 0, 44, 44);
                    p.setClipPath(path);
                    p.drawPixmap(0, 0, 44, 44, original.scaled(44, 44, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation));
                    p.setClipping(false);
                }
            } else {
                p.setBrush(QColor("#2C3545"));
                p.setPen(Qt::NoPen);
                p.drawEllipse(0, 0, 44, 44);
                p.setPen(Qt::white);
                p.setFont(QFont("Segoe UI", 12, QFont::Bold));
                p.drawText(pix.rect(), Qt::AlignCenter, fName.left(1).toUpper());
            }
            bool isOnline = f["online"].toBool();
            if (isOnline) {
                p.setBrush(QColor("#0F121A")); // dark background matching friends sidebar
                p.setPen(Qt::NoPen);
                p.drawEllipse(QPointF(34.0f, 34.0f), 7.0f, 7.0f);
                
                p.setBrush(QColor("#2ECC71"));
                p.drawEllipse(QPointF(34.0f, 34.0f), 4.5f, 4.5f);
            }
            
            // Real unread count badge from background poller
            QSettings settings("leVi Studios", "LuaPatcher");
            int savedMsgCount = settings.value("Social/MsgCount_" + fName, 0).toInt();
            int readMsgCount = settings.value("Social/ReadCount_" + fName, 0).toInt();
            int unreadCount = qMax(0, savedMsgCount - readMsgCount);
            if (unreadCount > 0) {
                p.setBrush(QColor("#0F121A")); // dark border background
                p.setPen(Qt::NoPen);
                p.drawEllipse(QPointF(10.0f, 10.0f), 10.0f, 10.0f);
                
                p.setBrush(QColor("#E74C3C")); // WhatsApp/iOS red
                p.drawEllipse(QPointF(10.0f, 10.0f), 8.0f, 8.0f);
                
                p.setPen(Qt::white);
                p.setFont(QFont("Segoe UI", 7, QFont::Bold));
                p.drawText(QRectF(0, 0, 20, 20), Qt::AlignCenter, QString::number(unreadCount));
            }
            p.end();
            av->setPixmap(pix);
            lay->addWidget(av);
            
            QVBoxLayout* info = new QVBoxLayout();
            info->setSpacing(2);
            info->setAlignment(Qt::AlignVCenter);
            
            QLabel* name = new QLabel(fName);
            name->setStyleSheet("color: white; font-weight: bold; font-size: 13px; background: transparent;");
            info->addWidget(name);

            
            lay->addLayout(info);
            lay->addStretch();
            
            m_friendsLayout->addWidget(friendBtn);
        }
    });
}

void MainWindow::openChat(const QString& friendUsername) {
    openChat(friendUsername, "");
}

void MainWindow::openChat(const QString& friendUsername, const QString& avatarUrl) {
    if (!m_chatPage) return;
    
    QSettings settings("leVi Studios", "LuaPatcher");
    settings.setValue("Social/cleared_" + friendUsername, true);
    
    // Mark messages as read by matching ReadCount to MsgCount
    int currentMsgCount = settings.value("Social/MsgCount_" + friendUsername, 0).toInt();
    settings.setValue("Social/ReadCount_" + friendUsername, currentMsgCount);
    
    refreshFriendsList();
    
    // Only save the previous index if we are NOT already on the chat page
    // This prevents getting trapped if we click multiple friends in a row
    if (m_stack->currentIndex() != 4) {
        m_prevStackIndex = m_stack->currentIndex();
    }
    
    // We need to re-create or re-initialize ChatPage with the new friend
    // For now, let's just delete and re-create to ensure a fresh session
    m_stack->removeWidget(m_chatPage);
    delete m_chatPage;
    
    m_chatPage = new ChatPage(m_username, friendUsername, avatarUrl, m_networkManager, this);
    connect(m_chatPage, &ChatPage::backRequested, this, &MainWindow::onChatBack);
    m_stack->insertWidget(4, m_chatPage);
    
    m_stack->setCurrentIndex(4);
}

void MainWindow::onChatBack() {
    m_stack->setCurrentIndex(m_prevStackIndex);
}

void MainWindow::removeFriend(const QString& friendUsername) {
    QJsonObject obj;
    obj["username"] = m_username;
    obj["friend_username"] = friendUsername;

    QUrl url(Config::WEBSERVER_BASE_URL + "/api/social/friends/remove");
    QNetworkRequest request(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

    QNetworkReply* reply = m_networkManager->post(request, QJsonDocument(obj).toJson());
    connect(reply, &QNetworkReply::finished, this, [this, reply, friendUsername]() {
        reply->deleteLater();
        if (reply->error() == QNetworkReply::NoError) {
            QMessageBox::information(this, "Success", "Successfully removed " + friendUsername + " from friends.");
            refreshFriendsList();
            
            // If we are currently chatting with them, close the chat
            if (m_chatPage && m_stack->currentIndex() == 4) {
                // Not ideal to assume but it works for now
                onChatBack();
            }
        } else {
            QMessageBox::warning(this, "Error", "Failed to remove friend. Error: " + reply->errorString());
        }
    });
}

void MainWindow::showBlurOverlay() {
    if (!m_blurOverlay) {
        m_blurOverlay = new QWidget(this);
        m_blurOverlay->setStyleSheet("background-color: rgba(10, 12, 16, 200);"); // Cinematic dark tint
    }
    
    m_blurOverlay->resize(this->size());
    m_blurOverlay->raise();
    m_blurOverlay->show();
}

void MainWindow::hideBlurOverlay() {
    if (m_blurOverlay) {
        m_blurOverlay->hide();
    }
}

void MainWindow::onNotificationClicked() {
    if (m_isGuest || m_username.isEmpty()) return;
    
    showBlurOverlay();
    
    NotificationDialog* dialog = new NotificationDialog(m_username, m_networkManager, 
                                                        m_hasUpdate, m_updateVersion, 
                                                        m_updateMessage, m_updateUrl, this);
    connect(dialog, &NotificationDialog::requestHandled, this, [this]() {
        refreshFriendsList();
        fetchNotificationCount();
    });
    connect(dialog, &QDialog::finished, this, [this]() {
        hideBlurOverlay();
        fetchNotificationCount(); // Refresh badge when dialog closes
    });
    
    dialog->setGeometry(
        (width() - dialog->width()) / 2,
        (height() - dialog->height()) / 2,
        dialog->width(),
        dialog->height()
    );
    dialog->show();
}

void MainWindow::fetchNotificationCount() {
    if (m_isGuest || m_username.isEmpty() || !m_networkManager) return;
    
    QString url = QString("%1/api/social/requests/pending?username=%2")
        .arg(Config::WEBSERVER_BASE_URL).arg(m_username);
    
    QNetworkReply* reply = m_networkManager->get(QNetworkRequest{QUrl(url)});
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        if (reply->error() != QNetworkReply::NoError) return;
        
        QJsonDocument doc = QJsonDocument::fromJson(reply->readAll());
        if (doc.isArray()) {
            int count = doc.array().size();
            if (m_mainNotifBadge) {
                if (m_hasUpdate || count > 0) {
                    int total = count + (m_hasUpdate ? 1 : 0);
                    m_mainNotifBadge->setText(total > 9 ? "9+" : QString::number(total));
                    m_mainNotifBadge->show();
                } else {
                    m_mainNotifBadge->hide();
                }
            }
        }
    });
}

void MainWindow::resizeEvent(QResizeEvent* event) {
    QMainWindow::resizeEvent(event);
    rearrangeGameGrid();
}

void MainWindow::rearrangeGameGrid(bool force) {
    if (!m_mainScrollArea || !m_gridLayout || m_gameCards.isEmpty()) return;

    // Viewport width is the actual space available for cards
    int availableWidth = m_mainScrollArea->viewport()->width() - 40; // Subtract padding/margins
    if (availableWidth < 200) availableWidth = 200; // Fallback
    
    int minCardWidth = 186;
    int spacing = 12;

    // Calculate max columns that fit based on minimum card width
    int cols = qMax(1, (availableWidth + spacing) / (minCardWidth + spacing));

    // Calculate the perfect flexible card width to fill the entire row
    // Subtract total spacing from available width, then divide by columns
    int flexCardWidth = (availableWidth - (cols - 1) * spacing) / cols;
    // Maintain exact 2:3 aspect ratio
    int flexCardHeight = flexCardWidth * 279 / 186; 

    // Skip relayout if column count and card size are identical to avoid CPU usage
    if (!force && cols == m_currentGridCols && m_gameCards.first()->width() == flexCardWidth) return;
    
    m_currentGridCols = cols;

    // Reposition and dynamically resize all cards
    for (int i = 0; i < m_gameCards.size(); i++) {
        m_gameCards[i]->setFixedSize(flexCardWidth, flexCardHeight);
        m_gridLayout->addWidget(m_gameCards[i], i / cols, i % cols);
    }
}

void MainWindow::updateSidebarAvatar() {
    if (!m_sidebarAvatarLabel) return;
    
    int avSz = 40;
    QPixmap avatarPix(avSz, avSz);
    avatarPix.fill(Qt::transparent);
    QPainter ap(&avatarPix);
    ap.setRenderHint(QPainter::Antialiasing);

    // Soft ring border
    ap.setPen(QPen(QColor(143, 171, 212, 80), 1.5));
    ap.setBrush(Qt::NoBrush);
    ap.drawEllipse(QRectF(1, 1, avSz - 2, avSz - 2));

    QString avUrl = m_userData["avatar_url"].toString();
    if (!avUrl.isEmpty()) {
        QPixmap original;
        original.loadFromData(QByteArray::fromBase64(avUrl.toUtf8()));
        if (!original.isNull()) {
            QPainterPath path;
            path.addEllipse(3, 3, avSz - 6, avSz - 6);
            ap.setClipPath(path);
            ap.drawPixmap(3, 3, avSz - 6, avSz - 6, original.scaled(avSz - 6, avSz - 6, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation));
            ap.setClipping(false);
        }
    } else {
        // Inner filled circle (avatar background)
        ap.setPen(Qt::NoPen);
        ap.setBrush(QColor("#4A6FA5"));
        ap.drawEllipse(QRectF(3, 3, avSz - 6, avSz - 6));

        // Letter initial
        ap.setPen(QColor(255, 255, 255, 240));
        ap.setFont(QFont("Segoe UI", 14, QFont::Bold));
        ap.drawText(QRectF(3, 3, avSz - 6, avSz - 6), Qt::AlignCenter, m_username.isEmpty() ? "U" : m_username.left(1).toUpper());
    }

    // Green online dot (bottom-right)
    int dotSz = 10;
    int dotX = avSz - dotSz - 1;
    int dotY = avSz - dotSz - 1;
    ap.setBrush(QColor(15, 20, 30));
    ap.setPen(Qt::NoPen);
    ap.drawEllipse(dotX - 2, dotY - 2, dotSz + 4, dotSz + 4);
    ap.setBrush(QColor("#2ECC71"));
    ap.drawEllipse(dotX, dotY, dotSz, dotSz);

    ap.end();
    m_sidebarAvatarLabel->setPixmap(avatarPix);
}

void MainWindow::checkAppUpdate() {
    QString url = Config::WEBSERVER_BASE_URL + "/api/app/latest-release";
    QNetworkRequest request{QUrl(url)};
    request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::AlwaysNetwork);
    
    QNetworkReply* reply = m_networkManager->get(request);
    connect(reply, &QNetworkReply::finished, this, [this, reply]() {
        reply->deleteLater();
        if (reply->error() != QNetworkReply::NoError) return;
        
        QJsonDocument doc = QJsonDocument::fromJson(reply->readAll());
        if (doc.isObject()) {
            QJsonObject obj = doc.object();
            QString latestVer = obj["version"].toString();
            
            // Simple version string comparison
            if (!latestVer.isEmpty() && latestVer != Config::APP_VERSION) {
                QStringList latestParts = latestVer.split('.');
                QStringList currentParts = Config::APP_VERSION.split('.');
                
                bool isNewer = false;
                for (int i = 0; i < qMin(latestParts.size(), currentParts.size()); ++i) {
                    int l = latestParts[i].toInt();
                    int c = currentParts[i].toInt();
                    if (l > c) { isNewer = true; break; }
                    if (l < c) { break; }
                }
                
                if (isNewer) {
                    m_hasUpdate = true;
                    m_updateVersion = latestVer;
                    m_updateMessage = obj["message"].toString();
                    m_updateUrl = obj["url"].toString();
                    
                    // Refresh the notification badge now that we know there's an update
                    fetchNotificationCount();
                }
            }
        }
    });
}