mainwindow.cpp

#include "mainwindow.h"

#include "qforeach.h"
#include "ui_mainwindow.h"

#include <QStorageInfo>
#include <QMessageBox>
#include <QProcess>
#include <QSettings>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QStandardItemModel>
#include <QtMultimediaWidgets/QtMultimediaWidgets>
#include <QtWidgets>
#include <QtMultimedia>


struct LightShow {
    QString title;
    QString audioDownloadLink;
    QString lightshowDownloadLink;
};

QList<LightShow> collectedLightshows;

struct Settings {
    int vehName; // Integer for vehicle name
};

QTimer *updateTimer;
bool VideoActive;

QList<QMediaPlayer*> mediaPlayers;
QList<QVideoWidget*> videoWidgets;

QWidget *cameraFront = nullptr;
QWidget *cameraBack = nullptr;
QWidget *cameraLeft = nullptr;
QWidget *cameraRight = nullptr;

qint64 lastpos_slider = 0;
bool wasPlaying;

QString configFilePath = QDir::currentPath() + "/tconfig.ini";
QString savFilePath = QDir::currentPath() + "/tdata.dat";


bool findTman(const QString& driveLetter) {
    // Ensure the drive letter has a trailing backslash
    QString rootDir = driveLetter;
    if (!rootDir.endsWith("/") && !rootDir.endsWith("\\")) {
        rootDir.append("/"); // Append a forward slash if it doesn't end with one
    }

    // Construct the path for tman.find
    QString tmanFilePath = rootDir + "tman.find";

    // Check if the file exists
    QFile tmanFile(tmanFilePath);
    if (tmanFile.exists()) {
        // Check if the file has hidden attribute (Windows specific check)
        QFileInfo fileInfo(tmanFilePath);
        if (fileInfo.isHidden()) {
            return true; // tman.find exists and is hidden
        }
    }

    return false; // File not found or not hidden
}

bool findFolder(const QString &drivePath, const QString &folderName) {
    QDir dir(drivePath);

    // Check if the directory exists
    if (!dir.exists()) {
        qDebug() << "The specified drive does not exist:" << drivePath;
        return false;
    }

    // Set filter to include only directories and exclude '.' and '..'
    dir.setFilter(QDir::NoDotAndDotDot | QDir::AllDirs);
    QFileInfoList entries = dir.entryInfoList();

    // Loop through the entries to find the target folder
    for (const QFileInfo &entry : entries) {
        if (entry.fileName() == folderName) {
            qDebug() << "Found folder:" << entry.absoluteFilePath();
            return true; // Folder found
        }
    }

    return false; // Folder not found
}

QStorageInfo getUSB() {
    QList<QStorageInfo> volumes = QStorageInfo::mountedVolumes();
    QStorageInfo usbStorageDevice;

    // Loop through each volume to find a suitable USB device
    for (const QStorageInfo &volume : volumes) {
        QString drive = volume.rootPath();
        if (drive.endsWith('/')) {
            drive.chop(1); // Remove the trailing slash
        }

        if ((findFolder(volume.rootPath(), "LightShow") && volume.fileSystemType() != "NTFS") ||
            (findFolder(volume.rootPath(), "TeslaCam") && volume.fileSystemType() != "NTFS")  ||
            (findTman(drive) && volume.fileSystemType() != "NTFS")) {
            usbStorageDevice = volume; // Assign the valid USB device
            break; // Exit the loop after finding the first valid device
        }
    }

    return usbStorageDevice;
}

QString getRootUSB() {
    QStorageInfo usbStorageDevice = getUSB(); // Use the helper function
    QString letter = usbStorageDevice.rootPath();
    if (letter.endsWith('/')) {
        letter.chop(1); // Remove the trailing slash
    }
    return letter;
}

void MainWindow::updateCheckboxes(QString& usbDriveLetter) {

    if (usbDriveLetter.endsWith('/')) {
        usbDriveLetter.chop(1); // Remove the trailing slash
    }

    // Check for TeslaCam folder
    if (findFolder(usbDriveLetter, "TeslaCam")) {
        ui->dashcam_enabled->setChecked(true); // Check dashcam_enabled if folder is found
    } else {
        ui->dashcam_enabled->setChecked(false); // Uncheck if folder is not found
    }

    // Check for LightShow folder
    if (findFolder(usbDriveLetter, "LightShow")) {
        ui->customLightshows_enabled->setChecked(true); // Check customLightshows_enabled if folder is found
    } else {
        ui->customLightshows_enabled->setChecked(false); // Uncheck if folder is not found
    }
}


// Create configuration file with default settings
void MainWindow::CreateConfig() {
    QSettings settings(configFilePath, QSettings::IniFormat);

    // Set default settings
    settings.beginGroup("General");
    settings.setValue("vehName", -1); // Default vehicle name
    settings.endGroup();

    qDebug() << "tconfig.ini created with default settings.";
}

// Load configuration settings
Settings loadConfig(MainWindow *mainWindow) {
    Settings settingsData;

    QFile configFile(configFilePath);

    // Check if the config file exists
    if (!configFile.exists()) {
        if (mainWindow) {
            mainWindow->CreateConfig(); // Call CreateConfig through the MainWindow instance
        } else {
            qDebug() << "Error: MainWindow instance is null. Cannot create config.";
            return settingsData; // Return default settings
        }
    }

    QSettings settings(configFilePath, QSettings::IniFormat);

    // Load settings
    settings.beginGroup("General");
    settingsData.vehName = settings.value("vehName", 1).toInt(); // Default to 1 if not found
    settings.endGroup();

    qDebug() << "tconfig.ini loaded. vehName:" << settingsData.vehName;

    return settingsData;
}

void MainWindow::SaveConfig() {
    QFile configFile(configFilePath);
    // Check if the config file exists
    if (!configFile.exists()) {
        CreateConfig();
    }

    QSettings settings(configFilePath, QSettings::IniFormat);

    // Begin saving settings
    settings.beginGroup("General");
    settings.setValue("vehName", ui->vehicles_comboBox->currentIndex()); // Default vehicle name
    settings.endGroup();
}



QString convertTo12HourFormat(const QString &time24hr) {
    QStringList timeParts = time24hr.split(':');
    if (timeParts.size() != 3) {
        qDebug() << "Invalid time format:" << time24hr;
        return QString();
    }

    int hour = timeParts.at(0).toInt();
    int minute = timeParts.at(1).toInt();
    int second = timeParts.at(2).toInt();

    QString period = (hour >= 12) ? "PM" : "AM";

    // Convert hour to 12-hour format
    if (hour == 0) {
        hour = 12; // Midnight
    } else if (hour > 12) {
        hour -= 12; // Afternoon/evening
    }

    return QString("%1:%2:%3 %4")
        .arg(hour, 2, 10, QChar('0'))    // Ensure 2-digit hour
        .arg(minute, 2, 10, QChar('0')) // Ensure 2-digit minute
        .arg(second, 2, 10, QChar('0')) // Ensure 2-digit second
        .arg(period);
}

QString getMonthName(int month) {
    static const QStringList monthNames = {
        "January", "February", "March", "April", "May", "June",
        "July", "August", "September", "October", "November", "December"
    };

    if (month >= 1 && month <= 12) {
        return monthNames.at(month - 1);
    }
    return "Invalid Month"; // Fallback for invalid month values
}


void MainWindow::loadDetectedClips(const QString &rootDir) {
    qDebug() << "Load: Begin detected clips";
    QString teslaCamDir = rootDir + "/TeslaCam";
    QString sentryClipsDir = teslaCamDir + "/SentryClips";
    QString savedClipsDir = teslaCamDir + "/SavedClips";

    QDir sentryDir(sentryClipsDir);
    QDir savedDir(savedClipsDir);

    // Create models for each tree view
    QStandardItemModel *sentryModel = new QStandardItemModel(this);
    QStandardItemModel *savedModel = new QStandardItemModel(this);
    ui->sentry_treeView->setModel(sentryModel);
    ui->savedclips_treeView->setModel(savedModel);

    auto processClipDirectory = [](const QString &clipDirPath, QStandardItemModel *model) {
        QDir dir(clipDirPath);
        QStringList videoFolders = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);

        QMap<QString, QStandardItem*> yearItems; // Map for year-level items
        QMap<QString, QStandardItem*> monthItems; // Map for month-level items

        for (const QString &folder : videoFolders) {
            QString fullFolderPath = clipDirPath + "/" + folder;
            QDir videoFolder(fullFolderPath);

            // Read event.json for metadata
            QFile eventFile(videoFolder.filePath("event.json"));
            if (eventFile.exists() && eventFile.open(QIODevice::ReadOnly)) {
                QJsonDocument doc = QJsonDocument::fromJson(eventFile.readAll());
                QJsonObject jsonObject = doc.object();


                QString timestamp = jsonObject.value("timestamp").toString();
                QString city = jsonObject.value("city").toString();
                QString reason = jsonObject.value("reason").toString();
                QStringList timestampParts = timestamp.split('T');
                if (timestampParts.size() != 2) {
                    qDebug() << "Invalid timestamp format:" << timestamp;
                    continue;
                }

                QString date = timestampParts.at(0); // Extract date part (YYYY-MM-DD)
                QString time = timestampParts.at(1); // Extract time part (hh:mm:ss)

                QStringList dateParts = date.split('-');
                if (dateParts.size() != 3) {
                    qDebug() << "Invalid date format:" << date;
                    continue;
                }

                QString year = dateParts.at(0);
                QString month = dateParts.at(1); // Month in MM format
                QString day = dateParts.at(2);

                // Convert time to 12-hour format
                QString time12Hour = convertTo12HourFormat(time);

                // Prepare display text for the clip
                QString displayText = QString("%1 [%2]").arg(date).arg(city.isEmpty() ? reason : city);

                // Check or create year node
                QStandardItem *yearItem = yearItems.value(year, nullptr);
                if (!yearItem) {
                    yearItem = new QStandardItem(year);
                    model->appendRow(yearItem);
                    yearItems[year] = yearItem;
                }

                // Check or create month node
                QString monthLabel = getMonthName(month.toInt()) + " (" + month + ")";
                QStandardItem *monthItem = monthItems.value(year + month, nullptr);
                if (!monthItem) {
                    monthItem = new QStandardItem(monthLabel);
                    yearItem->appendRow(monthItem);
                    monthItems[year + month] = monthItem;
                }

                // Add clip to month node
                QStandardItem *clipItem = new QStandardItem(displayText);
                clipItem->setIcon(QIcon(":/gui/build/Desktop_Qt_6_8_1_MinGW_64_bit-Debug/debug/video_icon.png"));
                monthItem->appendRow(clipItem);
            } else {
                qDebug() << "Missing or unreadable event.json in folder:" << folder;
            }
        }
    };

    // Process SentryClips and SavedClips
    processClipDirectory(sentryClipsDir, sentryModel);
    processClipDirectory(savedClipsDir, savedModel);

    qDebug() << "Load: Detected Sentry and Saved clips loaded.";
}




QString formatSize(qint64 bytes) {
    const double KB = 1024.0;
    const double MB = KB * 1024.0;
    const double GB = MB * 1024.0;
    const double TB = GB * 1024.0;

    double result = bytes;
    QString unit = "Bytes";

    if (bytes >= TB) {
        result = bytes / TB;
        unit = "TB";
    } else if (bytes >= GB) {
        result = bytes / GB;
        unit = "GB";
    } else if (bytes >= MB) {
        result = bytes / MB;
        unit = "MB";
    } else if (bytes >= KB) {
        result = bytes / KB;
        unit = "KB";
    }

    return QString::number(result, 'f', 2) + unit;
}

QString getVeh(int id) {
    switch (id) {
    case 0:
        return "Model S";
    case 1:
        return "Model X";
    case 2:
        return "Model 3";
    case 3:
        return "Model Y";
    case 4:
        return "Cybertruck";
    case 5:
        return "2017-2023 Model 3";
    case 6:
        return "2012-2020 Model S";
    case 7:
        return "2015-2020 Model X";
    default:
        return "Unknown Vehicle";
    }
}


void MainWindow::ShowWarningMsg(QString msg) {
    ui->warning_label->setText(msg);
    ui->warning_frame->show();
}




void MainWindow::ScanFolders() {
    ui->driveproperties_label->setText("Scanning..."); // Use old way to bypass error checks
    QList<QStorageInfo> volumes = QStorageInfo::mountedVolumes();
    bool tmanFound = false; // Flag to check if tman.find is found
    bool foldersFound = false; // Flag to check if folders are found

    // Loop through each volume and display details
    for (const QStorageInfo &volume : volumes) {
        QString rootPath = volume.rootPath();
        QString rootFreeSpace = formatSize(volume.bytesFree());
        QString formatted = "Detected Tesla Drive [" + rootPath + "] " + rootFreeSpace + " Free";
        qDebug() << "scan " + rootPath;

        if (findFolder(rootPath, "TeslaCam") || findFolder(rootPath, "LightShow")) {
            foldersFound = true; // At least one folder found
        }

        // Check if tman.find is found
        if (findTman(rootPath)) {
            tmanFound = true; // tman.find file found
        }

        if (foldersFound || tmanFound) {
            if (volume.fileSystemType() != "NTFS") {
                ui->radioButton->hide();
                ui->driveproperties_label->setText(formatted);
                ui->driveproperties_label->show();
                ui->reformat_drive->show();
                ui->warning_frame->hide();
                ui->loadCacheButton->setEnabled(true);
                ui->tabWidget->setTabEnabled(0, true);
                ui->tabWidget->setTabEnabled(1, true);
                ui->tabWidget->setCurrentIndex(0);
                QString usbDriveLetter = rootPath;
                if (!usbDriveLetter.endsWith("/") && !usbDriveLetter.endsWith("\\")) {
                    usbDriveLetter.append("/"); // Append a forward slash if it doesn't end with one
                }

                QString hiddenFilePath = usbDriveLetter + "/tman.find";
                QFile hiddenFile(hiddenFilePath);
                if (hiddenFile.open(QIODevice::WriteOnly)) {
                    hiddenFile.close(); // Close the file after creating it
                } else {
                    QMessageBox::critical(this, "Error", "Failed to create tman.find file.");
                    return;
                }

                // Set the hidden attribute using system command
                QString setHiddenCommand = QString("attrib +h \"%1\"").arg(hiddenFilePath);
                system(setHiddenCommand.toStdString().c_str());

                updateCheckboxes(rootPath);
                loadDetectedClips(rootPath);
                if ((volume.bytesTotal() * 1024 * 1024 * 1024) < 64) {
                    ShowWarningMsg("Warning: Your Tesla drive is under the recommended capacity of 64GB");
                }
                if (!foldersFound && tmanFound) {
                    // If no folders were found but tman.find was found
                    ShowWarningMsg("No files found on drive, please reformat or load cache.");
                    ui->driveproperties_label->setText("No files found on drive ["+usbDriveLetter+"]");
                    ui->pushButton_2->show();
                    ui->tabWidget->setTabEnabled(0, false);
                    ui->tabWidget->setTabEnabled(1, false);
                    ui->tabWidget->setCurrentIndex(2);
                }
                break;
            } else if (findFolder(rootPath, "TeslaCam") && volume.fileSystemType() != "NTFS" && findFolder(rootPath, "LightShow")) {
                ShowWarningMsg("Your Tesla drive cannot have custom lightshows and dashcam at the same time");
                ui->driveproperties_label->setText("Tesla Drive Detected, Multi Feature Violation");
                ui->pushButton_2->show();
                break;
            } else if (findFolder(rootPath, "TeslaCam") || findFolder(rootPath, "LightShow")) {
                ShowWarningMsg("Your Tesla drive is not exFAT, MS-DOS FAT (for Mac), ext3, or ext4");
                ui->driveproperties_label->setText("Tesla Drive Detected, Invalid formatting");
                ui->pushButton_2->show();
                break;
            }
        } else {
            ShowWarningMsg("No Tesla Drive Detected!");
            ui->radioButton->show();
            ui->reformat_drive->hide();
            ui->pushButton_2->hide();
            ui->driveproperties_label->setText("No Tesla Drive Detected");
            ui->loadCacheButton->setEnabled(false);
            ui->tabWidget->setTabEnabled(0, false);
            ui->tabWidget->setTabEnabled(1, false);
            ui->tabWidget->setCurrentIndex(2);
        }
    }
}

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    updateTimer = new QTimer(this);
    connect(updateTimer, &QTimer::timeout, this, &MainWindow::updateVideoUI);

    Settings configSettings = loadConfig(this);
    ui->warning_frame->hide();
    ui->pushButton_2->hide();
    //ui->videoButton_frame->hide();
    ui->comboBox->addItem("4xS");
    ui->comboBox->addItem("1xL");
    ui->comboBox->addItem("2xM");
    ui->comboBox->itemText(0);

    ui->videoButton_framebackwards->setIcon(style()->standardIcon(QStyle::SP_MediaSeekBackward));
    ui->videoButton_frameforward->setIcon(style()->standardIcon(QStyle::SP_MediaSeekForward));
    ui->videoButton_playpause->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
    ui->videoButton_startframe->setIcon(style()->standardIcon(QStyle::SP_MediaSkipBackward));
    ui->videoButton_skiptoend->setIcon(style()->standardIcon(QStyle::SP_MediaSkipForward));

    ui->vehicles_comboBox->addItem("Model S");
    ui->vehicles_comboBox->addItem("Model X");
    ui->vehicles_comboBox->addItem("Model 3");
    ui->vehicles_comboBox->addItem("Model Y");
    ui->vehicles_comboBox->addItem("Cybertruck");
    ui->vehicles_comboBox->addItem("2017-2023 Model 3");
    ui->vehicles_comboBox->addItem("2012-2020 Model S");
    ui->vehicles_comboBox->addItem("2015-2020 Model X");

    ui->vehicles_comboBox->setPlaceholderText(getVeh(configSettings.vehName));
    ui->vehicles_comboBox->setCurrentIndex(configSettings.vehName);

    ScanFolders();

    ui->recentClipsTab->setEnabled(false); // disable until implemented
}

MainWindow::~MainWindow()
{
    delete ui;
    delete updateTimer;
}

void MainWindow::on_radioButton_clicked() // scan drive button
{
    if (ui->radioButton->isChecked()) {
        ui->radioButton->setChecked(false);
    }

    ScanFolders();
}


void MainWindow::on_pushButton_clicked() // ack button
{
    ui->warning_frame->hide();
}

void MainWindow::formatDrive(const QString& driveLetter) {
    QMessageBox::StandardButton reply = QMessageBox::warning(
        this,
        "Warning",
        QString("Formatting will erase all data on the drive [%1]. Do you want to continue?").arg(driveLetter),
        QMessageBox::Yes | QMessageBox::No
        );

    if (reply == QMessageBox::Yes) {
        QString usbDriveLetter = driveLetter;
        qDebug() << "Beginning Format";

        // Ensure the drive letter has a trailing backslash removed
        if (usbDriveLetter.endsWith("/") || usbDriveLetter.endsWith("\\")) {
            usbDriveLetter.chop(1); // Remove the last character
        }

        // Create the format command
        QString command = QString("format %1 /FS:exFAT /Q /Y").arg(usbDriveLetter);
        qDebug() << command;

        // Call the system command
        int result = system(command.toStdString().c_str());

        // Check the result of the system call
        if (result != 0) {
            QMessageBox::critical(this, "Error", "Formatting failed. Please check the drive and try again.");
            return;
        }

        // Create the TeslaCam folder
        QDir usbDir(usbDriveLetter);
        if (!usbDir.exists()) {
            QMessageBox::critical(this, "Error", "Drive is not accessible.");
            return;
        }

        if (!usbDir.mkdir("TeslaCam")) {
            QMessageBox::critical(this, "Error", "Failed to create TeslaCam folder.");
            return;
        }

        // Create the tman.find file with hidden attribute
        QString hiddenFilePath = usbDriveLetter + "/tman.find";
        QFile hiddenFile(hiddenFilePath);
        if (hiddenFile.open(QIODevice::WriteOnly)) {
            hiddenFile.close(); // Close the file after creating it
        } else {
            QMessageBox::critical(this, "Error", "Failed to create tman.find file.");
            return;
        }

        // Set the hidden attribute using system command
        QString setHiddenCommand = QString("attrib +h \"%1\"").arg(hiddenFilePath);
        system(setHiddenCommand.toStdString().c_str());

        ScanFolders();
        QMessageBox::information(this, "Success", "Drive formatted to exFAT, TeslaCam folder created, and tman.find file created successfully.");
        ui->pushButton_2->hide();
    }
}


void MainWindow::on_pushButton_2_clicked() // format button
{
    formatDrive(getRootUSB());
}

void MainWindow::on_vehicles_comboBox_currentIndexChanged(int index)
{
    // Construct resource path
    QString resourcePath = ":/gui/build/Desktop_Qt_6_8_1_MinGW_64_bit-Debug/debug/" + QString::number(index) + ".png";
    QPixmap pixmap(resourcePath);

    if (!pixmap.isNull()) {
        // Set the pixmap directly; QLabel with scaled contents will handle resizing
        ui->label_3->setPixmap(pixmap);
    } else {
        qDebug() << "Failed to load resource image:" << resourcePath;
    }

    SaveConfig();
}

void MainWindow::resetLayout(int index) {

    // Clear any existing media players
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            lastpos_slider = mediaPlayer->position();
            // Disconnect signals if necessary
            disconnect(mediaPlayer); // Disconnect all signals

            // Stop the media player
            mediaPlayer->stop();

            // Delete the media player
            delete mediaPlayer;
        }
    }
    mediaPlayers.clear(); // Clear the list of media players

    // Reset global widget pointers
    cameraFront->disconnect();
    cameraFront = nullptr;
    cameraBack->disconnect();
    cameraBack = nullptr;
    cameraLeft->disconnect();
    cameraLeft = nullptr;
    cameraRight->disconnect();
    cameraRight = nullptr;

    // Clear the existing layout in videos_area
    QLayout *existingLayout = ui->videos_area->layout();
    if (existingLayout) {
        QLayoutItem *child;
        while ((child = existingLayout->takeAt(0)) != nullptr) {
            delete child->widget(); // Delete the widget
            delete child;           // Delete the layout item
        }
        delete existingLayout;
    }

    // Create a new layout
    QGridLayout *layout = new QGridLayout();
    layout->setContentsMargins(0, 0, 0, 0); // Set layout margins to 0

    switch (index) {
    case 0: // 4xS
    {
        // Create four small widgets in a 2x2 pattern
        QWidget *widgets[4] = {nullptr, nullptr, nullptr, nullptr};
        int count = 0;
        for (int row = 0; row < 2; ++row) {
            for (int col = 0; col < 2; ++col) {
                widgets[count] = new QWidget();
                widgets[count]->setStyleSheet("background-color: gray;");
                QGridLayout *smallLayout = new QGridLayout(widgets[count]);
                smallLayout->setContentsMargins(0, 0, 0, 0); // Set margins to 0
                layout->addWidget(widgets[count], row, col, 1, 1);
                count++;
            }
        }
        cameraFront = widgets[0];
        cameraBack = widgets[1];
        cameraLeft = widgets[2];
        cameraRight = widgets[3];
    }
    break;

    case 1: // 1xL
    {
        // Create one large widget filling the entire area
        QWidget *largeWidget = new QWidget();
        largeWidget->setStyleSheet("background-color: gray;");
        QGridLayout *largeLayout = new QGridLayout(largeWidget);
        largeLayout->setContentsMargins(0, 0, 0, 0); // Set margins to 0
        layout->addWidget(largeWidget, 0, 0, 3, 3); // Spanning all rows/columns
        cameraFront = largeWidget; // Assign to cameraFront
    }
    break;

    case 2: // 2xM
    {
        // Create two medium-sized widgets side-by-side
        QWidget *widgets[2] = {nullptr, nullptr};
        for (int col = 0; col < 2; ++col) {
            widgets[col] = new QWidget();
            widgets[col]->setStyleSheet("background-color: gray;");
            QGridLayout *smallLayout = new QGridLayout(widgets[col]);
            smallLayout->setContentsMargins(0, 0, 0, 0); // Set margins to 0
            layout->addWidget(widgets[col], 0, col, 1, 1);
        }
        cameraFront = widgets[0];
        cameraBack = widgets[1];
        // Remaining global pointers are already nullptr
    }
    break;

    default:
        qDebug() << "Invalid index selected.";
        break;
    }

    // Set the layout to videos_area
    ui->videos_area->setLayout(layout);
    setupContextMenus();

    if (VideoActive) {
        setupPreviewVideoPlayers();
    }
}

// Get the video file path for the selected camera
QString getCameraVideoPath(const QString &cameraSuffix) {
    return QCoreApplication::applicationDirPath() + "/previews/combined_" + cameraSuffix + ".mp4";
}

void MainWindow::on_comboBox_currentIndexChanged(int index)
{
    resetLayout(index);
}

void MainWindow::setupContextMenus() {
    QWidget *cameraWidgets[] = {cameraFront, cameraBack, cameraLeft, cameraRight};

    for (QWidget *widget : cameraWidgets) {
        if (widget) {
            widget->setContextMenuPolicy(Qt::CustomContextMenu);
            QObject::connect(widget, &QWidget::customContextMenuRequested, [widget, this](const QPoint &pos) {
                showContextMenu(widget, pos);
            });
        }
    }
}

// Show context menu for a widget
void MainWindow::showContextMenu(QWidget *widget, const QPoint &pos) {
    QMenu contextMenu;

    QAction *frontCameraAction = contextMenu.addAction("Set to Front Camera");
    QAction *backCameraAction = contextMenu.addAction("Set to Back Camera");
    QAction *leftCameraAction = contextMenu.addAction("Set to Left Camera");
    QAction *rightCameraAction = contextMenu.addAction("Set to Right Camera");

    QAction *selectedAction = contextMenu.exec(widget->mapToGlobal(pos));
    if (selectedAction) {
        lastpos_slider = mediaPlayers[0]->position();
        wasPlaying = mediaPlayers[0]->isPlaying();
        if (selectedAction == frontCameraAction) {
            setMediaSource(widget, "front");
        } else if (selectedAction == backCameraAction) {
            setMediaSource(widget, "back");
        } else if (selectedAction == leftCameraAction) {
            setMediaSource(widget, "left_repeater");
        } else if (selectedAction == rightCameraAction) {
            setMediaSource(widget, "right_repeater");
        }
    }
}

// Set media source for the widget's associated media player
void MainWindow::setMediaSource(QWidget *widget, const QString &camera) {
    QString videoPath = getCameraVideoPath(camera);

    if (widget == cameraFront && mediaPlayers[0]) {
        mediaPlayers[0]->setSource(QUrl::fromLocalFile(videoPath));
        mediaPlayers[0]->setPosition(lastpos_slider);
        mediaPlayers[0]->play();
        mediaPlayers[0]->pause();
        if (wasPlaying) {
            mediaPlayers[0]->play();
        }
    } else if (widget == cameraBack && mediaPlayers[1]) {
        mediaPlayers[1]->setSource(QUrl::fromLocalFile(videoPath));
        mediaPlayers[1]->setPosition(lastpos_slider);
        mediaPlayers[1]->play();
        mediaPlayers[1]->pause();
        if (wasPlaying) {
            mediaPlayers[1]->play();
        }
    } else if (widget == cameraLeft && mediaPlayers[2]) {
        mediaPlayers[2]->setSource(QUrl::fromLocalFile(videoPath));
        mediaPlayers[2]->setPosition(lastpos_slider);
        mediaPlayers[2]->play();
        mediaPlayers[2]->pause();
        if (wasPlaying) {
            mediaPlayers[2]->play();
        }
    } else if (widget == cameraRight && mediaPlayers[3]) {
        mediaPlayers[3]->setSource(QUrl::fromLocalFile(videoPath));
        mediaPlayers[3]->setPosition(lastpos_slider);
        mediaPlayers[3]->play();
        mediaPlayers[3]->pause();
        if (wasPlaying) {
            mediaPlayers[3]->play();
        }
    }
}

void MainWindow::on_savedclips_treeView_clicked(const QModelIndex &index)
{
    QString usbDriveLetter = getRootUSB();
    if (findFolder(usbDriveLetter, "TeslaCam")) {
        if (!usbDriveLetter.isEmpty()) {
            VideoActive = false;
            updateTimer->stop();
            handleTreeViewClick(index, usbDriveLetter + "/TeslaCam/SavedClips");
        }
    }
}

void MainWindow::on_sentry_treeView_clicked(const QModelIndex &index)
{
    QString usbDriveLetter = getRootUSB();

    if (findFolder(usbDriveLetter, "TeslaCam")) {
        if (!usbDriveLetter.isEmpty()) {
            VideoActive = false;
            updateTimer->stop();
            handleTreeViewClick(index, usbDriveLetter + "/TeslaCam/SentryClips");
        }
    }
}

QString joinVideos(const QList<QString>& videoFiles, const QString& cameraSuffix) {
    // Create the "previews" directory in the executable's directory
    QDir previewsDir(QCoreApplication::applicationDirPath() + "/previews");
    if (!previewsDir.exists()) {
        previewsDir.mkpath("."); // Create the directory
    }

    // Define the output path for the combined video
    QString outputPath = previewsDir.absoluteFilePath("combined_" + cameraSuffix + ".mp4");

    // Create a temporary file to hold the list of video files
    QString fileListPath = previewsDir.absoluteFilePath("file_list.txt");
    QFile file(fileListPath);
    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        qDebug() << "Failed to open file list for writing";
        return QString();
    }

    // Write the file list for ffmpeg
    for (const QString& videoFile : videoFiles) {
        file.write(QString("file '%1'\n").arg(videoFile).toUtf8());
    }
    file.close();

    // Prepare the ffmpeg command
    QString ffmpegPath = QCoreApplication::applicationDirPath() + "/tools/ffmpeg.exe"; // Replace with the actual path to ffmpeg.exe
    QStringList arguments;
    arguments << "-f" << "concat" << "-safe" << "0" << "-i" << fileListPath << "-c" << "copy" << outputPath;

    // Run ffmpeg process
    QProcess ffmpegProcess;
    ffmpegProcess.start(ffmpegPath, arguments);
    if (!ffmpegProcess.waitForFinished()) {
        qDebug() << "ffmpeg process did not finish successfully";
        return QString();
    }

    // Check if ffmpeg executed successfully
    QString output = ffmpegProcess.readAllStandardOutput();
    QString error = ffmpegProcess.readAllStandardError();
    if (!error.isEmpty()) {
        qDebug() << "ffmpeg error:" << error;
    }

    // Return the path to the combined video
    return outputPath;
}

void MainWindow::handleTreeViewClick(const QModelIndex &index, const QString &baseDir)
{
    // Get the text of the clicked item
    QString clickedText = index.data(Qt::DisplayRole).toString();
    qDebug() << "Clicked item text:" << clickedText;

    // Extract the date (YYYY-MM-DD) from the clicked text
    QRegularExpression dateRegex("^(\\d{4}-\\d{2}-\\d{2})"); // Match YYYY-MM-DD at the beginning
    QRegularExpressionMatch match = dateRegex.match(clickedText);
    if (!match.hasMatch()) {
        qDebug() << "Invalid date format or unrecognized text clicked:" << clickedText;
        return;
    }

    QString extractedDate = match.captured(1); // Extracted YYYY-MM-DD
    qDebug() << "Extracted date:" << extractedDate;

    // Search for a folder starting with the extracted date
    QDir baseDirObj(baseDir);
    QStringList matchingFolders = baseDirObj.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
    qDebug() << "Matching folders:" << matchingFolders;

    QString folderPath;
    for (const QString &folderName : matchingFolders) {
        if (folderName.startsWith(extractedDate)) {
            folderPath = baseDir + "/" + folderName;
            qDebug() << "Found matching folder:" << folderPath;
            break;
        }
    }

    if (folderPath.isEmpty()) {
        qDebug() << "No folder found starting with date:" << extractedDate;
        return;
    }

    QDir folderDir(folderPath);
    if (!folderDir.exists()) {
        qDebug() << "Folder does not exist for the clicked date:" << folderPath;
        return;
    }

    // Get all .mp4 files in the folder
    QStringList videoFiles = folderDir.entryList({"*.mp4"}, QDir::Files);
    qDebug() << "Video files found in folder:" << videoFiles;

    // Group videos by angle
    QMap<QString, QList<QString>> groupedVideos;
    for (const QString &fileName : videoFiles) {
        QStringList parts = fileName.split('-');
        if (parts.size() < 5) {
            qDebug() << "Skipping file due to insufficient parts:" << fileName;
            continue;
        }

        // Check and split parts if necessary
        QStringList newParts;
        for (const QString &part : parts) {
            if (part.contains("_") && !part.contains("repeater")) {
                // Split this part and add to newParts
                QStringList subParts = part.split("_");
                newParts.append(subParts);
            } else {
                newParts.append(part);
            }
        }

        // Use the last part to determine the camera angle
        QString cameraAngle = newParts.last();
        if (cameraAngle.endsWith(".mp4")) {
            cameraAngle.chop(4); // Remove ".mp4"
        }

        if (cameraAngle == "back" || cameraAngle == "front" ||
            cameraAngle == "left_repeater" || cameraAngle == "right_repeater") {
            groupedVideos[cameraAngle].append(folderPath + "/" + fileName);
            qDebug() << "Added video to group:" << cameraAngle << fileName;
        } else {
            qDebug() << "Unrecognized camera angle in file name:" << cameraAngle;
        }
    }

    // Sort each group by filename (timestamps)
    for (auto &group : groupedVideos) {
        std::sort(group.begin(), group.end());
        qDebug() << "Sorted group:" << group;
    }

    QProgressDialog progressDialog("Processing clips...", "Cancel", 0, groupedVideos.size(), this);
    progressDialog.setWindowModality(Qt::WindowModal); // Make it modal
    progressDialog.setMinimumDuration(0); // Show immediately
    progressDialog.show(); // Show the dialog now

    QCoreApplication::processEvents();

    setupVideoPlayers(groupedVideos, &progressDialog); // Pass the progress dialog
    qDebug() << "Video players set up with grouped videos.";
}
void MainWindow::setupVideoPlayers(const QMap<QString, QList<QString>> &groupedVideos, QProgressDialog *progressDialog)
{
    // Clear any existing media players
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            // Disconnect signals if necessary
            disconnect(mediaPlayer); // Disconnect all signals

            // Stop the media player
            mediaPlayer->stop();

            // Delete the media player
            delete mediaPlayer;
        }
    }
    mediaPlayers.clear(); // Clear the list of media players

    // Clear existing layout and set up new players, remove old previews
    QDir previewsDir(QCoreApplication::applicationDirPath() + "/previews");
    if (!previewsDir.exists()) {
        previewsDir.mkpath("."); // Create the directory
    }

    // Remove all existing files in the previews directory
    for (const QString& fileName : previewsDir.entryList(QDir::Files)) {
        previewsDir.remove(fileName); // Remove each file
    }

    QGridLayout *layout = new QGridLayout;
    layout->setContentsMargins(0, 0, 0, 0); // Set layout margins to 0
    int row = 0;

    // Initialize a list of camera widgets
    QWidget *cameraWidgets[4] = {cameraFront, cameraBack, cameraLeft, cameraRight};

    // Debug: Check the number of groups
    qDebug() << "Number of video groups:" << groupedVideos.size();

    int clipCount = 0; // Track the number of clips processed

    for (auto it = groupedVideos.begin(); it != groupedVideos.end() && row < 4; ++it) {
        const QList<QString>& videoFiles = it.value();

        // Join the videos and get the path to the combined video
        QString cameraSuffix = it.key(); // Use the key as the camera suffix
        QString combinedVideoPath = joinVideos(videoFiles, cameraSuffix);
        if (combinedVideoPath.isEmpty()) {
            qDebug() << "Failed to join videos for group:" << cameraSuffix;
            continue; // Skip this group if joining failed
        }

        // Debug: Log the current group and its combined video
        qDebug() << "Group:" << cameraSuffix << "Combined video:" << combinedVideoPath;

        // Create media player and video widget
        QMediaPlayer* mediaPlayer = new QMediaPlayer(this);
        // Check if a video widget already exists at the current row
        QVideoWidget* videoWidget;
        if (row < videoWidgets.size() && videoWidgets[row]) {
            videoWidget = videoWidgets[row]; // Reuse existing video widget
        } else {
            videoWidget = new QVideoWidget; // Create a new video widget if it doesn't exist
            if (row < videoWidgets.size()) {
                videoWidgets[row] = videoWidget; // Update the list if resizing
            } else {
                videoWidgets.append(videoWidget); // Append if necessary
            }
        }

        mediaPlayers.append(mediaPlayer);
        mediaPlayer->setVideoOutput(videoWidget);
        mediaPlayer->setSource(QUrl::fromLocalFile(combinedVideoPath)); // Set the combined video as the source

        // Play the combined video
        mediaPlayer->play();
        mediaPlayer->pause();

        // Set the video widget to stretch to fit
        videoWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        videoWidget->setAspectRatioMode(Qt::IgnoreAspectRatio); // Ignore aspect ratio to stretch to fit

        // Assign the video widget to the corresponding camera widget
        if (cameraWidgets[row]) {
            QLayout* cameraLayout = cameraWidgets[row]->layout();
            if (!cameraLayout) {
                cameraLayout = new QGridLayout();
                cameraWidgets[row]->setLayout(cameraLayout); // Set layout if not already set
            }
            cameraLayout->addWidget(videoWidget); // Add video widget to the corresponding camera widget
            // Debug: Log the assignment of video widget
            qDebug() << "Assigned video widget to camera widget at row:" << row;
        } else {
            // Debug: Log if the camera widget is null
            qDebug() << "Camera widget at row" << row << "is null.";
        }

        // Update progress dialog
        clipCount++;
        progressDialog->setValue(clipCount);
        progressDialog->setMaximum(groupedVideos.size());

        // Check if the user has clicked the cancel button
        if (progressDialog->wasCanceled()) {
            // Optionally, handle cancellation logic here
            break;
        }

        row++; // Move to the next row
    }

    // Close the progress dialog
    progressDialog->close();

    // Set the layout to videos_area
    ui->videos_area->setLayout(layout);
    // Debug: Log the final layout set
    qDebug() << "Layout set for videos_area with" << row << "rows.";
    VideoActive = true;
    updateTimer->start(1000);
}


void MainWindow::setupPreviewVideoPlayers()
{
    // Clear any existing media players
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            // Disconnect signals if necessary
            disconnect(mediaPlayer); // Disconnect all signals

            // Stop the media player
            mediaPlayer->stop();

            // Delete the media player
            delete mediaPlayer;
        }
    }
    mediaPlayers.clear(); // Clear the list of media players

    videoWidgets.clear(); // Clear the list of video widgets

    // Create a new layout for video widgets
    QGridLayout *layout = new QGridLayout;
    layout->setContentsMargins(0, 0, 0, 0); // Set layout margins to 0
    int row = 0;

    // Initialize a list of camera widgets
    QWidget *cameraWidgets[4] = {cameraFront, cameraBack, cameraLeft, cameraRight};

    // Map camera angles to preview filenames
    QMap<QString, QString> previewFiles = {
        {"front", "combined_front.mp4"},
        {"back", "combined_back.mp4"},
        {"left", "combined_left_repeater.mp4"},
        {"right", "combined_right_repeater.mp4"}
    };

    // Path to the previews folder
    QString previewsDirPath = QCoreApplication::applicationDirPath() + "/previews";
    QDir previewsDir(previewsDirPath);

    if (!previewsDir.exists()) {
        qDebug() << "Previews directory does not exist:" << previewsDirPath;
        return; // Exit if the directory doesn't exist
    }

    for (const QString &cameraSuffix : previewFiles.keys()) {
        QString previewFilePath = previewsDirPath + "/" + previewFiles[cameraSuffix];

        // Check if the preview file exists
        if (!QFile::exists(previewFilePath)) {
            qDebug() << "Preview file not found for camera angle:" << cameraSuffix;
            continue; // Skip if the preview file is missing
        }

        // Debug: Log the current preview file
        qDebug() << "Using preview file:" << previewFilePath;

        // Create media player and video widget
        QMediaPlayer* mediaPlayer = new QMediaPlayer(this);
        QVideoWidget* videoWidget = new QVideoWidget; // Always create a new video widget

        mediaPlayers.append(mediaPlayer);
        videoWidgets.append(videoWidget); // Track the new video widget

        mediaPlayer->setVideoOutput(videoWidget);
        mediaPlayer->setSource(QUrl::fromLocalFile(previewFilePath)); // Set the preview file as the source

        // Play the preview video

        mediaPlayer->play();

        // Set the video widget to stretch to fit
        videoWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        videoWidget->setAspectRatioMode(Qt::IgnoreAspectRatio); // Ignore aspect ratio to stretch to fit

        // Assign the video widget to the corresponding camera widget
        if (row < 4 && cameraWidgets[row]) {
            QLayout* cameraLayout = cameraWidgets[row]->layout();
            if (!cameraLayout) {
                cameraLayout = new QGridLayout();
                cameraWidgets[row]->setLayout(cameraLayout); // Set layout if not already set
            }
            cameraLayout->addWidget(videoWidget); // Add video widget to the corresponding camera widget
            qDebug() << "Assigned video widget to camera widget at row:" << row;
        } else {
            qDebug() << "Camera widget at row" << row << "is null.";
        }

        row++; // Move to the next row
    }

    // Set the layout to videos_area
    ui->videos_area->setLayout(layout);
    qDebug() << "Layout set for videos_area with" << row << "rows.";
    VideoActive = true;
    updateTimer->start(1000);
}

void MainWindow::on_videoButton_startframe_clicked()
{
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            mediaPlayer->setPosition(0); // Set position to start (0 milliseconds)
        }
    }
}

void MainWindow::on_videoButton_framebackwards_clicked()
{
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            qint64 currentPosition = mediaPlayer->position();
            qint64 newPosition = qMax(currentPosition - 10000, static_cast<qint64>(0)); // Go back 10 seconds
            mediaPlayer->setPosition(newPosition);
        }
    }
}

void MainWindow::on_videoButton_playpause_clicked()
{
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            if (mediaPlayer->isPlaying()) {
                mediaPlayer->pause();
                ui->videoButton_playpause->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
            } else {
                mediaPlayer->play();
                ui->videoButton_playpause->setIcon(style()->standardIcon(QStyle::SP_MediaPause));
            }
        }
    }
}

void MainWindow::on_videoButton_frameforward_clicked()
{
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            qint64 currentPosition = mediaPlayer->position();
            qint64 duration = mediaPlayer->duration();
            qint64 newPosition = qMin(currentPosition + 10000, duration); // Go forward 10 seconds
            mediaPlayer->setPosition(newPosition);
        }
    }
}

void MainWindow::on_videoButton_skiptoend_clicked()
{
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            mediaPlayer->setPosition(mediaPlayer->duration()); // Skip to the end of the video
        }
    }
}

void MainWindow::updateVideoUI()
{
    // Update UI for all media players
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            if (lastpos_slider != 0) {
                mediaPlayer->setPosition(lastpos_slider);
            }

            qint64 position = mediaPlayer->position();
            qint64 duration = mediaPlayer->duration();
            ui->videoButton_videoslider->setMaximum(duration);
            // Update the slider
            ui->videoButton_videoslider->setValue(position);
            // Update the current time label
            ui->videoButton_starttime->setText(QTime::fromMSecsSinceStartOfDay(position).toString("hh:mm:ss"));
            // Update the total time label
            ui->videoButton_totaltime->setText(QTime::fromMSecsSinceStartOfDay(duration).toString("hh:mm:ss"));
        }
    }
    lastpos_slider = 0;
}

void MainWindow::on_videoButton_videoslider_sliderReleased()
{
    // Update UI for all media players
    for (QMediaPlayer *mediaPlayer : mediaPlayers) {
        if (mediaPlayer) {
            mediaPlayer->setPosition(ui->videoButton_videoslider->sliderPosition());
        }
    }
}

QString trimToRelativePath(const QString &absolutePath) {
    QUrl url(absolutePath);
    QString filePath = url.toLocalFile(); // Convert URL to local file path

    // Check if the path contains "/previews/"
    int index = filePath.indexOf("/previews/");
    if (index != -1) {
        return ".." + filePath.mid(index); // Add ".." and return the relative path
    }

    return filePath; // Return the full path if "/previews/" is not found
}


void MainWindow::on_exportclip_Button_clicked()
{
    // Options for export types
    QStringList exportTypes = {
        "Layout",
        "Front Camera",
        "Back Camera",
        "Left Camera",
        "Right Camera",
        "All Cameras Individually"
    };

    // Show a dialog for the user to select the export type
    bool ok;
    QString selectedType = QInputDialog::getItem(this, "Select Export Type", "Export Type:", exportTypes, 0, false, &ok);

    if (!ok || selectedType.isEmpty()) {
        return; // User cancelled or no selection
    }

    QString destinationPath;
    QFileDialog fileDialog;

    // Handle the different export types
    if (selectedType == "All Cameras Individually") {
        destinationPath = fileDialog.getExistingDirectory(this, "Select Destination Folder", QCoreApplication::applicationDirPath());
        if (destinationPath.isEmpty()) {
            return; // User cancelled
        }

        // Copy individual camera files to the selected folder
        QStringList cameraFiles = {
            "combined_front.mp4",
            "combined_back.mp4",
            "combined_left_repeater.mp4",
            "combined_right_repeater.mp4"
        };

        for (const QString &cameraFile : cameraFiles) {
            QString sourcePath = QCoreApplication::applicationDirPath() + "/previews/" + cameraFile;
            QString destPath = destinationPath + "/" + cameraFile;
            QFile::copy(sourcePath, destPath);
        }

        QMessageBox::information(this, "Export Complete", "Videos exported successfully.");
        QDesktopServices::openUrl(QUrl::fromLocalFile(destinationPath)); // Open the folder

    } else if (selectedType == "Front Camera" || selectedType == "Back Camera" ||
               selectedType == "Left Camera" || selectedType == "Right Camera") {
        QString cameraFileName;

        // Determine the correct filename based on the selected camera type
        if (selectedType == "Front Camera") {
            cameraFileName = "combined_front.mp4";
        } else if (selectedType == "Back Camera") {
            cameraFileName = "combined_back.mp4";
        } else if (selectedType == "Left Camera") {
            cameraFileName = "combined_left_repeater.mp4";
        } else if (selectedType == "Right Camera") {
            cameraFileName = "combined_right_repeater.mp4";
        }

        QString sourcePath = QCoreApplication::applicationDirPath() + "/previews/" + cameraFileName;

        destinationPath = fileDialog.getSaveFileName(this, "Export Video", sourcePath, "MP4 Files (*.mp4)");
        if (destinationPath.isEmpty()) {
            return; // User cancelled
        }

        // Copy the selected camera file to the destination path
        QFile::copy(sourcePath, destinationPath);
        QMessageBox::information(this, "Export Complete", "Video exported successfully.");
        QDesktopServices::openUrl(QUrl::fromLocalFile(destinationPath)); // Open the file location

    } else if (selectedType == "Layout") {
        // Get the selected layout from the combo box (assuming it's named layoutComboBox)
        int layoutIndex = ui->comboBox->currentIndex();
        QString sourcePath = QCoreApplication::applicationDirPath() + "/previews";

        // Show a file dialog for the destination folder
        destinationPath = fileDialog.getSaveFileName(this, "Export Video", sourcePath, "MP4 Files (*.mp4)");
        if (destinationPath.isEmpty()) {
            return; // User cancelled
        }

        // Get dynamic sources from widgets
        QString frontSource = trimToRelativePath(mediaPlayers[0]->source().toString());
        QString backSource = trimToRelativePath(mediaPlayers[1]->source().toString());
        QString leftSource = trimToRelativePath(mediaPlayers[2]->source().toString());
        QString rightSource = trimToRelativePath(mediaPlayers[3]->source().toString());

        QString layoutCommand;

        // Determine the layout command based on the selected index
        switch (layoutIndex) {
        case 0: // 4xS
            layoutCommand = QString("-i %1 -i %2 -i %3 -i %4 -filter_complex "
                                    "[0:v][1:v]hstack=inputs=2[top];[2:v][3:v]hstack=inputs=2[bottom];[top][bottom]vstack=inputs=2[vout] "
                                    "-preset ultrafast -threads 4 -map [vout] -s 1280x720 -y %5")
                                .arg(frontSource, backSource, leftSource, rightSource, destinationPath);
            break;
        case 1: // 1xL
            layoutCommand = QString("-i %1 -filter_complex "
                                    "[0:v]scale=1280:-1,crop=1280:720:(in_w-out_w)/2:(in_h-out_h)/2[vout] "
                                    "-map [vout] -preset ultrafast -threads 4 -y %2")
                                .arg(frontSource, destinationPath);
            break;
        case 2: // 2xM
            layoutCommand = QString("-i %1 -i %2 -filter_complex "
                                    "[0:v][1:v]hstack=inputs=2[vout] "
                                    "-preset ultrafast -threads 4 -map [vout] -s 1280x720 -y %3")
                                .arg(frontSource, backSource, destinationPath);
            break;
        default:
            QMessageBox::warning(this, "Invalid Layout", "Please select a valid layout.");
            return;
        }

        // Debug: Print the FFmpeg command to console
        qDebug() << "Executing FFmpeg Command:" << layoutCommand;

        // Show progress dialog while executing the FFmpeg command
        QProgressDialog progressDialog(this);
        progressDialog.setWindowTitle("Exporting Video");
        progressDialog.setLabelText("Exporting layout video...");
        progressDialog.show();

        QCoreApplication::processEvents();
        QCoreApplication::processEvents();
        QCoreApplication::processEvents();

        // Show progress dialog while executing the FFmpeg command
        QProcess process;
        process.setProgram("tools/ffmpeg.exe");
        process.setWorkingDirectory(QCoreApplication::applicationDirPath() + "/tools");

        process.setArguments(layoutCommand.split(" ")); // Split the command into arguments

        // Redirect standard output and error
        process.setProcessChannelMode(QProcess::MergedChannels);

        // Start the process
        process.start();
        if (!process.waitForStarted()) {
            qDebug() << "Failed to start the FFmpeg process.";
            return;
        }

        // Wait for the process to finish with an increased timeout
        if (!process.waitForFinished(3000000)) { // Increase timeout to xx minutes
            qDebug() << "FFmpeg process did not finish in time.";
            // Optionally, you can terminate the process if needed
            process.terminate();
            return;
        }

        progressDialog.close();

        // Capture the output and errors after the process finishes
        QString output = process.readAll();
        qDebug() << "Final FFmpeg Output:" << output;

        // Check the exit status
        if (process.exitCode() == 0) {
            QMessageBox::information(this, "Export Complete", "Layout video exported successfully.");
            QDesktopServices::openUrl(QUrl::fromLocalFile(destinationPath)); // Open the folder
        } else {
            QMessageBox::warning(this, "Export Failed", "Failed to export the layout video. Check the debug console for details.");
        }
    }

}

QString fetchPage(const QString& url) {
    QNetworkAccessManager manager;
    QNetworkRequest request(url);
    QNetworkReply* reply = manager.get(request);

    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    if (reply->error() != QNetworkReply::NoError) {
        qWarning() << "Error fetching page:" << reply->errorString();
        return "";
    }

    QString htmlContent = reply->readAll();
    reply->deleteLater();
    return htmlContent;
}

void scrapePage(const QString& htmlContent) {
    // Extract title
    QRegularExpression titleRegex(R"(<h1 style=\"word-break:break-word;\">(.*?)<\/h1>)");
    QRegularExpressionMatch titleMatch = titleRegex.match(htmlContent);
    if (!titleMatch.hasMatch()) {
        qWarning() << "Title not found";
        return;
    }
    QString title = titleMatch.captured(1).trimmed();

    // Extract audio download link
    QRegularExpression audioRegex(R"(<a href=\"(\/public\/uploads\/sound\/[^\"]+)\".*?class=\"btn btn-primary.*?download-sound\")");
    QRegularExpressionMatch audioMatch = audioRegex.match(htmlContent);
    QString audioDownloadLink;
    if (audioMatch.hasMatch()) {
        audioDownloadLink = "https://teslalightshare.io" + audioMatch.captured(1);
    } else {
        qWarning() << "Audio download link not found";
        return;
    }

    // Extract lightshow download link
    QRegularExpression lightshowRegex(R"(<a href=\"(\/public\/uploads\/fseq\/[^\"]+)\".*?class=\"btn btn-primary.*?download-fseq\")");
    QRegularExpressionMatch lightshowMatch = lightshowRegex.match(htmlContent);
    QString lightshowDownloadLink;
    if (lightshowMatch.hasMatch()) {
        lightshowDownloadLink = "https://teslalightshare.io" + lightshowMatch.captured(1);
    } else {
        qWarning() << "Lightshow download link not found";
        return;
    }

    // Add to collectedLightshows if both links exist
    if (!audioDownloadLink.isEmpty() && !lightshowDownloadLink.isEmpty()) {
        collectedLightshows.append({title, audioDownloadLink, lightshowDownloadLink});
        qDebug() << "Collected Lightshow:";
        qDebug() << "Title:" << title;
        qDebug() << "Audio Download Link:" << audioDownloadLink;
        qDebug() << "Lightshow Download Link:" << lightshowDownloadLink;
        qDebug() << "-------------------------";
    }
}

void downloadLightshow(const QString& audioUrl, const QString& lightshowUrl, const QString& title, QWidget* parent) {
    // Get executable directory
    QString exeDir = QCoreApplication::applicationDirPath();
    QString tmpDir = exeDir + "/tmp";
    QString usbDir = getRootUSB() + "/LightShow";

    // Ensure tmp and USB folders exist
    QDir().mkpath(tmpDir);
    QDir().mkpath(usbDir);

    // Generate a unique 5-character GUID
    QString newGuid = QUuid::createUuid().toString(QUuid::Id128).left(5);

    // Convert title to lowercase
    QString sanitizedTitle = title.toLower();

    // Replace spaces with underscores
    sanitizedTitle.replace(" ", "_");

    // Remove any character that is not A-Z, a-z, 0-9, or _
    sanitizedTitle.remove(QRegularExpression("[^a-zA-Z0-9_]"));

    // Ensure it's not empty (fallback to "lightshow" if it gets completely stripped)
    if (sanitizedTitle.isEmpty()) {
        sanitizedTitle = "lightshow";
    }


    QString newBaseName = sanitizedTitle + "_" + newGuid;


    // Setup file paths
    QString audioFileName = QFileInfo(audioUrl).fileName();
    QString lightshowFileName = QFileInfo(lightshowUrl).fileName();

    QString tmpAudioPath = tmpDir + "/" + audioFileName;
    QString tmpLightshowPath = tmpDir + "/" + lightshowFileName;

    QString audioExtension = QFileInfo(audioUrl).suffix();
    QString lightshowExtension = QFileInfo(lightshowUrl).suffix();

    QString newAudioPath = usbDir + "/" + newBaseName + "." + audioExtension;
    QString newLightshowPath = usbDir + "/" + newBaseName + "." + lightshowExtension;

    // Network manager for downloading
    QNetworkAccessManager* manager = new QNetworkAccessManager(parent);

    auto downloadFile = [&](const QString& url, const QString& savePath, const QString& finalPath, const QString& fileType) {
        QNetworkRequest request(url);
        QNetworkReply* reply = manager->get(request);

        // Create progress dialog
        QProgressDialog* progressDialog = new QProgressDialog(QString("Downloading %1...").arg(fileType), "Cancel", 0, 100, parent);
        progressDialog->setWindowModality(Qt::WindowModal);
        progressDialog->setMinimumDuration(500);
        progressDialog->show();

        // Connect progress updates
        QObject::connect(reply, &QNetworkReply::downloadProgress, progressDialog, [=](qint64 bytesReceived, qint64 bytesTotal) {
            if (bytesTotal > 0) {
                progressDialog->setValue(static_cast<int>((bytesReceived * 100) / bytesTotal));
            }
        });

        // Handle download completion
        QObject::connect(reply, &QNetworkReply::finished, [=]() {
            progressDialog->close();
            if (reply->error() == QNetworkReply::NoError) {
                QFile file(savePath);
                if (file.open(QIODevice::WriteOnly)) {
                    file.write(reply->readAll());
                    file.close();
                    QFile::rename(savePath, finalPath);
                    qDebug() << "Downloaded and moved:" << finalPath;
                }
            } else {
                qWarning() << "Download failed:" << reply->errorString();
            }
            reply->deleteLater();
            progressDialog->deleteLater();
        });

        // Handle cancel button
        QObject::connect(progressDialog, &QProgressDialog::canceled, reply, &QNetworkReply::abort);
    };

    // Start downloads with progress tracking
    downloadFile(audioUrl, tmpAudioPath, newAudioPath, "Audio File");
    downloadFile(lightshowUrl, tmpLightshowPath, newLightshowPath, "Lightshow File");
}

// Function to load lightshows from XML
void loadLightshowsFromXml(const QString& filePath) {
    QFile file(filePath);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        qWarning() << "Failed to open lightshows.xml for reading";
        return;
    }

    QXmlStreamReader xmlReader(&file);
    while (!xmlReader.atEnd() && !xmlReader.hasError()) {
        xmlReader.readNext();
        if (xmlReader.isStartElement() && xmlReader.name() == "lightshow") {
            LightShow lightshow;
            while (!(xmlReader.isEndElement() && xmlReader.name() == "lightshow")) {
                xmlReader.readNext();
                if (xmlReader.isStartElement()) {
                    if (xmlReader.name() == "title") {
                        lightshow.title = xmlReader.readElementText();
                    } else if (xmlReader.name() == "audioDownloadLink") {
                        lightshow.audioDownloadLink = xmlReader.readElementText();
                    } else if (xmlReader.name() == "lightshowDownloadLink") {
                        lightshow.lightshowDownloadLink = xmlReader.readElementText();
                    }
                }
            }
            collectedLightshows.append(lightshow);
        }
    }

    if (xmlReader.hasError()) {
        qWarning() << "Error reading XML:" << xmlReader.errorString();
    }

    file.close();
}

// Function to save lightshows to XML
void saveLightshowsToXml(const QString& filePath) {
    QFile file(filePath);
    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        qWarning() << "Failed to open lightshows.xml for writing";
        return;
    }

    QXmlStreamWriter xmlWriter(&file);
    xmlWriter.setAutoFormatting(true);
    xmlWriter.writeStartDocument();
    xmlWriter.writeStartElement("lightshows");

    for (const LightShow& lightshow : collectedLightshows) {
        xmlWriter.writeStartElement("lightshow");
        xmlWriter.writeTextElement("title", lightshow.title);
        xmlWriter.writeTextElement("audioDownloadLink", lightshow.audioDownloadLink);
        xmlWriter.writeTextElement("lightshowDownloadLink", lightshow.lightshowDownloadLink);
        xmlWriter.writeEndElement(); // lightshow
    }

    xmlWriter.writeEndElement(); // lightshows
    xmlWriter.writeEndDocument();
    file.close();
}

void MainWindow::on_tabWidget_currentChanged(int index)
{
    if (index == 1) { // Active window is lightshow
        QString usbDriveLetter = getRootUSB();

        if (findFolder(usbDriveLetter, "TeslaCam") || findFolder(usbDriveLetter, "LightShow")) {
            if (!usbDriveLetter.isEmpty()) {
                if (findFolder(usbDriveLetter, "TeslaCam")) {

                } else { // do stuff if valid
                    ui->customLightshows_enabled->setEnabled(true);

                    QString xmlFilePath = QCoreApplication::applicationDirPath() + "/lightshows.xml";
                    if (QFile::exists(xmlFilePath)) {
                        loadLightshowsFromXml(xmlFilePath);
                    } else {
                        QMessageBox::StandardButton reply;
                        reply = QMessageBox::question(this, "TManager", "TManager needs to query the lightshows, this can take some time. Would you like to do this now? If you do not do this, you cannot download new lightshows.",
                                                      QMessageBox::Yes | QMessageBox::No);
                        if (reply == QMessageBox::Yes) {
                            // Show progress dialog
                            QProgressDialog progressDialog("Fetching lightshows...", "Cancel", 0, 1000, this);
                            progressDialog.setWindowModality(Qt::WindowModal);
                            progressDialog.setValue(0);

                            // Fetch and scrape data
                            for (int i = 1; i <= 1000; ++i) {
                                QString url = "https://teslalightshare.io/light-show/" + QString::number(i);
                                qDebug() << "Fetching:" << url;

                                QString htmlContent = fetchPage(url);
                                if (!htmlContent.isEmpty()) {
                                    scrapePage(htmlContent);
                                }

                                progressDialog.setValue(i);
                                if (progressDialog.wasCanceled()) {
                                    break; // Exit the loop if canceled
                                }
                            }

                            // Save the collected lightshows to XML
                            saveLightshowsToXml(xmlFilePath);
                        } else {
                            // Handle case where user does not want to scrape
                            QMessageBox::information(this, "Information", "You will not be able to download new lightshows.");
                        }
                    }

                    // Clear existing widgets safely
                    if (ui->lightshowOptions->layout() == nullptr) {
                        ui->lightshowOptions->setLayout(new QVBoxLayout());
                    } else {
                        QLayoutItem* child;
                        while ((child = ui->lightshowOptions->layout()->takeAt(0)) != nullptr) {
                            delete child->widget();
                            delete child;
                        }
                    }

                    // Create a search bar at the top
                    QHBoxLayout* searchLayout = new QHBoxLayout();
                    QLineEdit* searchBar = new QLineEdit();
                    searchBar->setPlaceholderText("Search lightshows...");
                    searchBar->setClearButtonEnabled(true);
                    searchLayout->addWidget(searchBar);

                    // Create a scrollable container
                    QScrollArea* scrollArea = new QScrollArea();
                    scrollArea->setWidgetResizable(true);
                    QWidget* scrollWidget = new QWidget();
                    QVBoxLayout* scrollLayout = new QVBoxLayout(scrollWidget);
                    scrollWidget->setLayout(scrollLayout);
                    scrollArea->setWidget(scrollWidget);

                    // Add search bar and scroll area to the main layout
                    QVBoxLayout* mainLayout = qobject_cast<QVBoxLayout*>(ui->lightshowOptions->layout());
                    mainLayout->addLayout(searchLayout);
                    mainLayout->addWidget(scrollArea);

                    // Populate the lightshow list
                    for (const LightShow& lightshow : collectedLightshows) {
                        QFrame* frame = new QFrame();
                        frame->setFrameShape(QFrame::StyledPanel);
                        frame->setFrameShadow(QFrame::Raised);

                        QVBoxLayout* frameLayout = new QVBoxLayout(frame);

                        QLabel* titleLabel = new QLabel(lightshow.title);
                        frame->setProperty("lightshowTitle", lightshow.title); // Store title in frame property
                        frameLayout->addWidget(titleLabel);

                        QPushButton* downloadButton = new QPushButton("Install Lightshow");
                        frameLayout->addWidget(downloadButton);

                        // Button click connection
                        connect(downloadButton, &QPushButton::clicked, this, [=]() {
                            downloadLightshow(lightshow.audioDownloadLink, lightshow.lightshowDownloadLink, lightshow.title, this);
                        });

                        frame->setLayout(frameLayout);
                        scrollLayout->addWidget(frame);
                    }

                    // Add stretch to keep layout clean
                    scrollLayout->addStretch();

                    connect(searchBar, &QLineEdit::textChanged, this, [=](const QString& text) {
                        for (auto* frame : scrollWidget->findChildren<QFrame*>()) {
                            QLabel* titleLabel = frame->findChild<QLabel*>(); // Find the QLabel inside the frame
                            if (titleLabel) {
                                QString title = titleLabel->text();
                                bool match = title.contains(text, Qt::CaseInsensitive);
                                frame->setVisible(match);
                            }
                        }
                    });
                }
            }
        }
    }
}

qint64 dirSize(QString dirPath) {
    qint64 size = 0;
    QDir dir(dirPath);
    //calculate total size of current directories' files
    QDir::Filters fileFilters = QDir::Files|QDir::System|QDir::Hidden;
    for(QString filePath : dir.entryList(fileFilters)) {
        QFileInfo fi(dir, filePath);
        size+= fi.size();
    }
    //add size of child directories recursively
    QDir::Filters dirFilters = QDir::Dirs|QDir::NoDotAndDotDot|QDir::System|QDir::Hidden;
    for(QString childDirPath : dir.entryList(dirFilters))
        size+= dirSize(dirPath + QDir::separator() + childDirPath);
    return size;
}
void MainWindow::moveFiles(const QString& sourcePath, const QString& destinationPath) {
    QProgressDialog progressDialog("Moving files...", "Cancel", 0, 100, this);
    progressDialog.setWindowModality(Qt::WindowModal);
    progressDialog.setMinimumDuration(0);
    progressDialog.show();

    QDir sourceDir(sourcePath);
    if (!sourceDir.exists()) {
        QMessageBox::warning(this, "Error", "Source directory does not exist!");
        return;
    }

    QDir destDir(destinationPath);
    if (!destDir.exists()) {
        if (!destDir.mkpath(destinationPath)) {
            QMessageBox::warning(this, "Error", "Failed to create destination directory: " + destinationPath);
            return;
        }
    }

    QStringList entries = sourceDir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
    int totalEntries = entries.size();
    int processedEntries = 0;

    bool canceled = false;
    foreach (const QString& entry, entries) {
        QString srcEntry = sourceDir.filePath(entry);
        QString destEntry = destDir.filePath(entry);

        QFileInfo entryInfo(srcEntry);
        if (entryInfo.isDir()) {
            // Recursively handle subdirectories
            moveFiles(srcEntry, destEntry);
        } else {
            // Move individual files
            if (!QFile::rename(srcEntry, destEntry)) {
                QMessageBox::warning(this, "Error", "Failed to move file: " + entry);
                canceled = true;
                break;
            }
        }

        processedEntries++;
        int progress = (processedEntries * 100) / totalEntries;
        progressDialog.setValue(progress);

        // Check if user canceled
        if (progressDialog.wasCanceled()) {
            canceled = true;
            break;
        }
    }

    // If operation was canceled, stop and return
    if (canceled) {
        progressDialog.close();
        QMessageBox::information(this, "Operation Canceled", "File move operation was canceled.");
        return;
    }

    // Remove the source directory if empty
    if (sourceDir.entryList(QDir::NoDotAndDotDot | QDir::AllEntries).isEmpty()) {
        sourceDir.rmdir(sourcePath);
    }

    progressDialog.close();
    //QMessageBox::information(this, "Operation Complete", "Files have been successfully moved.");
}

void MainWindow::on_customLightshows_enabled_stateChanged(int arg1) {

}

void MainWindow::on_dashcam_enabled_checkStateChanged(const Qt::CheckState& arg1) {

}

void MainWindow::cacheDashcam(const QString& usbDriveLetter) {

    QString dashcamSize = formatSize(dirSize(usbDriveLetter + "/TeslaCam"));

    // Check if the size is 0.00
    if (dashcamSize.contains("0.00")) {
        QMessageBox deleteAskMsgBox;
        deleteAskMsgBox.setText("No files found in the TeslaCam folder. Do you want to delete the folder?");
        deleteAskMsgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
        int deleteAskRet = deleteAskMsgBox.exec();

        if (deleteAskRet == QMessageBox::Yes) {
            QDir teslaCamDir(usbDriveLetter + "/TeslaCam");
            if (teslaCamDir.exists()) {
                teslaCamDir.removeRecursively();
            }
        }
        return; // Exit the function
    }


    QMessageBox cacheMsgBox;
    cacheMsgBox.setText("Do you want to cache your dashcam? Required Storage: [ " + formatSize(dirSize(usbDriveLetter + "/TeslaCam")) + " ]");
    cacheMsgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
    int cacheRet = cacheMsgBox.exec();

    if (cacheRet == QMessageBox::Yes) {
        QString cachePath = QCoreApplication::applicationDirPath() + "/cache/dashcam";
        QString timestamp = QDateTime::currentDateTime().toString("yyyy_MM_dd-hh_mm_ss");
        QString dashcamCachePath = cachePath + "/cam_cache_" + timestamp;
        QDir cacheDir(dashcamCachePath);

        if (!cacheDir.exists()) {
            cacheDir.mkpath(".");
        }

        // Check if there's enough local space
        qint64 requiredSpace = dirSize(usbDriveLetter + "/TeslaCam");
        qint64 availableSpace = QStorageInfo(QCoreApplication::applicationDirPath()).bytesFree();

        if (requiredSpace > availableSpace) {
            QMessageBox spaceMsgBox;
            spaceMsgBox.setText("Not enough space in the local cache.");
            spaceMsgBox.setInformativeText("Do you want to cache externally?");
            spaceMsgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
            int spaceRet = spaceMsgBox.exec();

            if (spaceRet == QMessageBox::Yes) {
                QString externalCachePath = QFileDialog::getExistingDirectory(this, "Select Cache Directory");
                if (!externalCachePath.isEmpty()) {
                    moveFiles(usbDriveLetter + "/TeslaCam", externalCachePath);
                }
            }
        } else {
            moveFiles(usbDriveLetter + "/TeslaCam", dashcamCachePath);
        }
    } else {
        QMessageBox deleteAskMsgBox;
        deleteAskMsgBox.setText("Do you want to delete the TeslaCam folder?");
        deleteAskMsgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
        int deleteAskRet = deleteAskMsgBox.exec();

        if (deleteAskRet == QMessageBox::Yes) {
            QDir teslaCamDir(usbDriveLetter + "/TeslaCam");
            if (teslaCamDir.exists()) {
                teslaCamDir.removeRecursively();
            }
        }
    }

}

void MainWindow::cacheLightshow(const QString& usbDriveLetter) {

    QString lightShowSize = formatSize(dirSize(usbDriveLetter + "/LightShow"));

    // Check if the size is 0.00
    if (lightShowSize.contains("0.00")) {
        QMessageBox deleteAskMsgBox;
        deleteAskMsgBox.setText("No files found in the LightShow folder. Do you want to delete the folder?");
        deleteAskMsgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
        int deleteAskRet = deleteAskMsgBox.exec();

        if (deleteAskRet == QMessageBox::Yes) {
            QDir lightShowDir(usbDriveLetter + "/LightShow");
            if (lightShowDir.exists()) {
                lightShowDir.removeRecursively();
            }
        }
        return; // Exit the function
    }


    QMessageBox cacheMsgBox;
    cacheMsgBox.setText("Do you want to cache your LightShow folder? Required Storage: [ " + formatSize(dirSize(usbDriveLetter + "/LightShow")) + " ]");
    cacheMsgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
    int cacheRet = cacheMsgBox.exec();

    if (cacheRet == QMessageBox::Yes) {
        QString cachePath = QCoreApplication::applicationDirPath() + "/cache/lightshow/active";
        QDir activeDir(cachePath);

        if (activeDir.exists()) {
            // Clear the "active" folder
            activeDir.setFilter(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
            foreach (const QString& entry, activeDir.entryList()) {
                QFileInfo entryInfo(activeDir.filePath(entry));
                if (entryInfo.isDir()) {
                    QDir(entryInfo.filePath()).removeRecursively();
                } else {
                    activeDir.remove(entry);
                }
            }
        } else {
            activeDir.mkpath(".");
        }

        moveFiles(usbDriveLetter + "/LightShow", cachePath);
    } else {
        QMessageBox deleteAskMsgBox;
        deleteAskMsgBox.setText("Do you want to delete the LightShow folder?");
        deleteAskMsgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
        int deleteAskRet = deleteAskMsgBox.exec();

        if (deleteAskRet == QMessageBox::Yes) {
            QDir lightShowDir(usbDriveLetter + "/LightShow");
            if (lightShowDir.exists()) {
                lightShowDir.removeRecursively();
            }
        }
    }
}

void MainWindow::detectCacheLightshow(const QString& usbDriveLetter) {
    QString cachePath = QCoreApplication::applicationDirPath() + "/cache/lightshow/active";
    QDir activeDir(cachePath);

    if (activeDir.exists() && !activeDir.entryList(QDir::Files | QDir::NoDotAndDotDot).isEmpty()) {
        QMessageBox msgBox;
        msgBox.setText("You have an active lightshow cached. Would you like to use it?");
        msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
        int ret = msgBox.exec();

        if (ret == QMessageBox::Yes) {
            QString lightShowPath = usbDriveLetter + "/LightShow";
            QDir lightShowDir(lightShowPath);
            if (!lightShowDir.exists()) {
                lightShowDir.mkpath("."); // Create LightShow folder if it doesn't exist
            }

            // Clear the LightShow folder if not empty
            QStringList existingFiles = lightShowDir.entryList(QDir::Files | QDir::NoDotAndDotDot);
            foreach (const QString& file, existingFiles) {
                lightShowDir.remove(file);
            }

            // Move the files from the active cache to the LightShow folder
            moveFiles(cachePath, lightShowPath);
            QMessageBox::information(this, "Lightshow Restored", "Active lightshow cache has been restored to the LightShow folder on USB.");
        }
    } else {
        QMessageBox::information(this, "No Active Lightshow Cache Found", "No active lightshow cache was detected.");

        while (true) {
            QMessageBox msgBox;
            msgBox.setText("Do you have an external lightshow cache?");
            msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
            int ret = msgBox.exec();

            if (ret == QMessageBox::No) {
                return; // User does not have an external cache, exit
            } else {
                QString externalFolder = QFileDialog::getExistingDirectory(this, "Select External Lightshow Cache Folder");
                if (externalFolder.isEmpty()) {
                    continue; // User canceled, prompt again
                }

                QDir externalDir(externalFolder);
                QStringList lightshowFiles = externalDir.entryList(QDir::Files | QDir::NoDotAndDotDot);
                bool isValidCache = true;

                // Check if the folder contains at least one `.fseq` or `.mp3` file
                foreach (const QString& file, lightshowFiles) {
                    if (file.endsWith(".fseq", Qt::CaseInsensitive) || file.endsWith(".mp3", Qt::CaseInsensitive) || file.endsWith(".wav", Qt::CaseInsensitive)) {
                        isValidCache = true;
                        break;
                    }
                }

                if (!isValidCache) {
                    QMessageBox::warning(this, "Invalid Cache", "The selected folder is not a valid lightshow cache.");
                } else {
                    QString lightShowPath = usbDriveLetter + "/LightShow";
                    QDir lightShowDir(lightShowPath);
                    if (!lightShowDir.exists()) {
                        lightShowDir.mkpath("."); // Create LightShow folder if it doesn't exist
                    }

                    // Clear the LightShow folder if not empty
                    QStringList existingFiles = lightShowDir.entryList(QDir::Files | QDir::NoDotAndDotDot);
                    foreach (const QString& file, existingFiles) {
                        lightShowDir.remove(file);
                    }

                    // Move the files from the external cache to the LightShow folder
                    moveFiles(externalFolder, lightShowPath);
                    QMessageBox::information(this, "Lightshow Restored", "External lightshow cache has been restored to the LightShow folder on USB.");
                    return;
                }
            }
        }
        QDir rootDir(usbDriveLetter);
        if (!rootDir.exists("LightShow")) {
            rootDir.mkpath("LightShow"); // Create LightShow folder if it doesn't exist
        }
    }
}

void MainWindow::detectDashcamCache(const QString& usbDriveLetter) {
    QString cachePath = QCoreApplication::applicationDirPath() + "/cache/dashcam";
    QDir cacheDir(cachePath);

    if (cacheDir.exists() && !cacheDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot).isEmpty()) {
        QStringList cacheFolders = cacheDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);

        if (cacheFolders.size() == 1) {
            QString cacheFolderPath = cacheDir.filePath(cacheFolders.first());
            QMessageBox msgBox;
            msgBox.setText("You have a cached dashcam. Would you like to use it?");
            msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
            int ret = msgBox.exec();

            if (ret == QMessageBox::Yes) {
                moveFiles(cacheFolderPath, usbDriveLetter + "/TeslaCam");
                loadDetectedClips(usbDriveLetter);
                QMessageBox::information(this, "Dashcam Restored", "Dashcam cache has been restored to TeslaCam.");
                return;
            }
        } else {
            QMessageBox msgBox;
            msgBox.setText("You have a multiple cached dashcam's. Would you like to select one?");
            msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
            int ret = msgBox.exec();
            if (ret == QMessageBox::Yes) {
                while (true) {
                    QString selectedFolder = QFileDialog::getExistingDirectory(this, "Select Dashcam Cache Folder", cachePath);
                    if (selectedFolder.isEmpty()) {
                        break; // User canceled
                    }

                    QFileInfo selectedFolderInfo(selectedFolder);
                    if (!selectedFolderInfo.fileName().contains(QRegularExpression(R"(\d{4}_\d{2}_\d{2}-\d{2}_\d{2}_\d{2})"))) {
                        QMessageBox::warning(this, "Invalid Selection", "The selected folder is not a valid dashcam cache. Please try again.");
                        int retry = QMessageBox::question(this, "Load Cache", "Do you want to load another cache?", QMessageBox::Yes | QMessageBox::No);
                        if (retry == QMessageBox::No) {
                            return;
                        }
                    } else {
                        moveFiles(selectedFolder, usbDriveLetter + "/TeslaCam");
                        loadDetectedClips(usbDriveLetter);
                        QMessageBox::information(this, "Dashcam Restored", "Dashcam cache has been restored to TeslaCam.");
                        return;
                    }
                }
            }
        }
    } else {
        QMessageBox::information(this, "No Dashcam Cache Found", "No dashcam cache was detected in the default directory.");

        while (true) {
            QMessageBox msgBox;
            msgBox.setText("Do you have an external dashcam cache?");
            msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
            int ret = msgBox.exec();

            if (ret == QMessageBox::No) {
                // Create TeslaCam folder and subfolders if no cache
                QDir teslaCamDir(usbDriveLetter + "/TeslaCam");
                if (!teslaCamDir.exists()) {
                    teslaCamDir.mkpath("TeslaCam/RecentClips");
                    teslaCamDir.mkpath("TeslaCam/SavedClips");
                    teslaCamDir.mkpath("TeslaCam/SentryClips");
                }
                QMessageBox::information(this, "Dashcam Enabled", "TeslaCam folder has been created with required subfolders.");
                return;
            } else {
                QString externalFolder = QFileDialog::getExistingDirectory(this, "Select External Dashcam Cache Folder");
                if (externalFolder.isEmpty()) {
                    continue; // User canceled, prompt again
                }

                QDir externalDir(externalFolder);
                QStringList requiredFolders = {"SentryClips", "SavedClips", "RecentClips"};
                bool isValidCache = true;

                foreach (const QString& folder, requiredFolders) {
                    if (!externalDir.exists(folder)) {
                        isValidCache = false;
                        break;
                    }
                }

                if (!isValidCache) {
                    QMessageBox::warning(this, "Invalid Cache", "The selected folder is not a valid dashcam cache.");
                } else {
                    moveFiles(externalFolder, usbDriveLetter + "/TeslaCam");
                    loadDetectedClips(usbDriveLetter);
                    QMessageBox::information(this, "Dashcam Restored", "External dashcam cache has been restored to TeslaCam.");
                    return;
                }
            }
        }
    }
}

void MainWindow::on_formatA_drive_clicked() {
    // Get the list of available drives
    QStringList driveList;
    foreach (const QStorageInfo &storageInfo, QStorageInfo::mountedVolumes()) {
        if (storageInfo.isReady() && storageInfo.isValid()) {
            driveList.append(storageInfo.rootPath());
        }
    }

    // Show a dialog for the user to select the drive
    bool ok;
    QString selectedDrive = QInputDialog::getItem(this, "Select Drive", "Drive:", driveList, 0, false, &ok);

    if (selectedDrive.endsWith('/')) {
        selectedDrive.chop(1); // Remove the trailing slash
    }

    if (!ok || selectedDrive.isEmpty()) {
        return; // User cancelled or no selection
    }

    // Proceed to format the selected drive
    formatDrive(selectedDrive); // Call your existing format function
}

void MainWindow::on_reformat_drive_clicked()
{
    formatDrive(getRootUSB());
}


void MainWindow::on_dashcam_enabled_clicked()
{
    QString usbDriveLetter = getRootUSB();

    if (findFolder(usbDriveLetter, "LightShow")) {
        if (!usbDriveLetter.isEmpty() && ui->dashcam_enabled->isChecked()) {
            ui->dashcam_enabled->setChecked(false);

            // Prompt user to disable custom lightshows
            QMessageBox msgBox;
            msgBox.setText("To enable the dashcam feature, custom lightshows need to be disabled.");
            msgBox.setInformativeText("Do you want to disable custom lightshows?");
            msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
            int ret = msgBox.exec();

            if (ret == QMessageBox::Yes) {
                cacheLightshow(usbDriveLetter); // Call lightshow caching logic
                QDir rootDir(usbDriveLetter);
                if (!rootDir.exists("TeslaCam")) {
                    rootDir.mkpath("TeslaCam"); // Create LightShow folder if it doesn't exist
                }
                ui->dashcam_enabled->setChecked(true);
            }
        }
    } else {
        if (ui->dashcam_enabled->isChecked() == false) {
            cacheDashcam(usbDriveLetter);
        } else {
            detectDashcamCache(usbDriveLetter);
        }
    }
    updateCheckboxes(usbDriveLetter);
}


void MainWindow::on_customLightshows_enabled_clicked()
{
    QString usbDriveLetter = getRootUSB();

    if (findFolder(usbDriveLetter, "TeslaCam")) {
        if (!usbDriveLetter.isEmpty() && ui->customLightshows_enabled->isChecked()) {
            ui->customLightshows_enabled->setChecked(false);

            // Prompt user to disable dashcam
            QMessageBox msgBox;
            msgBox.setText("To enable custom lightshows, the dashcam feature needs to be disabled.");
            msgBox.setInformativeText("Do you want to disable the dashcam feature?");
            msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
            int ret = msgBox.exec();

            if (ret == QMessageBox::Yes) {
                cacheDashcam(usbDriveLetter); // Call dashcam caching logic
                QDir rootDir(usbDriveLetter);
                if (!rootDir.exists("LightShow")) {
                    rootDir.mkpath("LightShow"); // Create LightShow folder if it doesn't exist
                }
                ui->customLightshows_enabled->setChecked(true);
            }
        }
    } else {
        if (ui->customLightshows_enabled->isChecked() == false) {
            cacheLightshow(usbDriveLetter);
        }else {
            detectCacheLightshow(usbDriveLetter);
        }
    }
    updateCheckboxes(usbDriveLetter);
}


void MainWindow::on_loadCacheButton_clicked()
{
    QStringList options = {"Dashcam","Lightshow"};
    // Show a dialog for the user to select the drive
    bool ok;
    QString selectedOption = QInputDialog::getItem(this, "Select Cache Option", "Cache:", options, 0, false, &ok);


    if (!ok || selectedOption.isEmpty()) {
        return; // User cancelled or no selection
    }

    if (selectedOption == "Dashcam") {
        detectDashcamCache(getRootUSB());
    } else {
        detectCacheLightshow(getRootUSB());
    }

}